程序员干货分享

LogicJava知识点总结

2020-10-14  本文已影响0人  小白菜aaa

JDK和JRE

开发Java程序

Java程序结构

类public class 类
        主方法(程序入口) public static void main(String[] args){
            （功能性代码）java代码
        }

转义字符

注释

标注解释
调试代码

    行注释
        //
    块注释
        /*

        */

数据类型

数据类型转换

        int num=10;
        object obj=num;  //装箱
        num=(int)obj;    //拆箱

变量名

只能由数字，字母，下划线和$组成，只能以字母和下划线开头

运算符

num1+=num2; 　
num1=num1+num2;

如果==两边的变量为值类型，代表两个值是否相等
如果＝＝两便的值为引用类型，判断两个引用对象是否为同一对象
String类型比较是否相同
String1.equals(String2);

int num1=10;
int num2=100;
int max=num1>num2?num1:num2;

结构化程序设计

顺序结构
选择结构　　根据不同情况选择不同的操作
循环结构　　在特定条件下重复执行某些操作

选择结构

 if(条件) {
        代码块1
    }
 代码块2

如果条件为true，先执行代码块1再执行代码块2，为false忽略代码块1执行代码块2
当代码块1只有一条语句时{}可以省略

if(条件){
            代码块1
        }else{
            代码块2
        }
代码块3

如果条件为true执行代码块1，如果为false执行代码块2
两个分支必然执行一个

else—if（范围比较 也可以进行等值比较）

if(条件1){
        操作1;
    }else if(条件2){
        操作2
    }else if(条件3){
        操作3
    }else{
        else操作
    }

else-if 结构总会有一个分支被执行

switch-case（等值比较）

switch（score被比较值/表达式）{
            case 比较值1/选项：
                代码块
                break;
            case 比较值1：
                代码块
                break;
            case 比较值1：
                代码块
                break;
            default：
                default操作
                break;
        }

switch-case结构只执行和被比较值相同的选项对应的操作,当所有的选项不满足时执行default操作,选项之间没有先后顺序。
break
1：声明操作的范围
2：终止整个switch结构
3：省略会执行当前选项后执行下一个选项的操作
注意

1：被比较值和选项数据类型必须一致（或者被比较值兼容选项）
2：被比较值为String类型时JDK版本必须大于1.6
　　支持int long short 枚举 String
3：case穿透
　　在省略break操作时，选项会出现穿透问题，效果一个选项多个操作

循环结构

 while(条件){   //适用于循环次数不固定的循环
                    操作
                }


for(初始化循环变量;循环条件;更新循环变量){//循环次数固定
                    操作
                }


do{
        操作
   }while(条件);


for(数据类型    迭代变量:数据源){
                    操作迭代变量
}
迭代变量只读不写

break
终止整个循环结构
在循环中遇到break语句时循环会忽略break之后所有的语句，执行循环结构之后的语句
continue
中止整个循环结构，进入下一次循环
在循环中遇到continue语句时循环会忽略continue之后所有的语句，开始一次新的循环

数组

数组是一个变量，用来存放一组具有相同数据类型的数据

        num=10;
        num1[1]=10;
        int[] num4=new int[]{1,2,3,4,5,6,7};
        System.out.println("num4[4]="+num4[4]);

4：使用
数组名[下标]
数组排序

import java.util.Arrays;
            Arrays.sort(数组)//进行永久性的排序

类和对象

类： 类是类型，是一个抽象的概念
　　　将具有相同属性和行为的实体中，具有的相同属性和行为抽离出来组成类
对象：对象是一个实体，是真实存在的
　　　对象具有类中所有的属性和行为

变量
　成员变量—全局变量
　　　直接在类中定义，不在方法中定义
　局部变量
　　　定义在方法中的变量
区别：
　　　1：作用域
　　　　　　变量的作用于都为自身外侧最近的一对{} 内
　　　　　　成员变量在类中任何位置都可以定义，类中的方法都可以使用，与变量定义位置和方法位置无关
　　　　　　局部变量必须在定义之后才能使用
　　　2：初始化
　　　　　　Java会为全局变量指定一个默认值
　　　　　　 值类型 0
　　　　　　引用类型 null
　　　　　　布尔类型 false
　　　　　　 Java不会为局部变量指定默认值，必须先赋值后使用
　　　3：优先级
　　　　　　在同一个类中出现同名的全局变量和局部变量时
　　　　　　局部变量优先级高于全局变量
　　　　　　如果在类中使用全局变量 this.属性名
　　　　　　this代表当前类

创建

public class 类名{
            //类名首字母必须大写，并且和文件名保持一致
            -----属性模板-----属性表示类的特征
            数据类型   属性名; 
            数据类型   属性名; 
            数据类型   属性名; 
            数据类型   属性名; 

            -----方法模板-----  方法表示类的行为，能力，或功能 
            访问修饰符   [static][abstract] 返回值类型    方法名([形参列表]){
                操作
                [return 返回值]
            }       

        }

使用

            创建对象
            类名 对象名=new 类名();
            使用对象的属性和方法
            对象名.属性
            对象名.方法([实参列表]);

有参／无参

无参方法
        没有参数的方法
        返回值类型
            void        没有返回值
            数据类型        有返回值  
有参方法
        参数就是方法执行时所要处理的数据
        public 返回值类型  方法名（数据类型1 参数1，数据类型2 参数2，····，数据类型n 参数n）{
            操作
            [return 返回值];
        }   
方法使用
        没有返回值并且没有参数的
            类内  方法名();
            类外  对象名.方法名();
        有返回值并且没有参数的
            类内  数据类型 变量=方法名();
                直接将方法名()放在使用的位置上，作为值使用
            类外  数据类型 变量=对象名.方法名();
                直接将象名.方法名()放在使用的位置上，作为值使用
        有参的（返回值参考上方）
            类内  方法名(实参列表)
            类外  对象名.方法名(实参列表);
                实参列表是程序真正要处理的数据列表，不出现数据类型，并且实参列表的数据的数据的数据类型和形参列表保持一致

实参和形参
形式参数：在方法定义时对参数的称呼，只起占位作用
实际参数：在方法调用时对参数的称呼，方法真正处理的数据
实参和形参的顺序和数据类型保持一致
实参和形参的数量保持一致

字符串

String
　　 length() 取长度
    charAt(int index) 取对应位置的字符
    indexOf(String str)
    indexOf(int ch)
    indexOf(char ch)
        获取字符串中第一次出现参数的位置
    indexOf(String str,int fromIndex)
    indexOf(int ch,int fromIndex)
    indexOf(char ch,int fromIndex)
        获取字符串中在fromIndex之后第一次出现参数的位置
    lastIndexOf(String str)
    lastIndexOf(int ch)
    lastIndexOf(char ch)
        获取字符串中最后一次出现参数的位置
    subString(int index)
        截取index之后所有的内容，生成一个新的字符串，不影响原字符串
    subString(int beginIndex,int endIndex)
        截取beginIndex之后,endIndex之前所有的内容，生成一个新的字符串，不影响原字符串
        包含beginIndex位不包含endIndex位，包头不含尾。
    spilt(int ch)
    spilt(String str)    返回值位String[]
        根据参数将字符串分割位字符串数组，新数组中的元素不包含参数
    trim()
        得到一个前后两端不包含空格的字符串
    concat(String str)
        将参数拼接到字符串后，生成一个新的字符串    
StringBuffer    
        append(String str)
            将参数拼接到StringBuffer对象后
        insert(int index,String str)    
            在index位插入str
        length()
            获取StringBuffer对象的长度
        toString()
            StringBuffer对象转换为String对象

结尾

感谢看到最后的朋友，都看到最后了，点个赞再走啊，如有不对之处还请多多指正。

上一篇下一篇

猜你喜欢

热点阅读