java基础

数据类型分类：

基本数据类型：

数值型、字符型、布尔型
		数值型：整数型、浮点型
		整数型：{short、int、long}
		浮点型：{float、double}
		字符型：{char、byte}
		布尔型：{boolean}
注意：数据类型自动转换；取值类型小的自动转换成取值的类型{如：int + byte=int}
	   强制转换：数据类型 变量名=（数据类型 ）被转换值

引用数据类型：

数组、类、接口

运算符：

	数值运算符、赋值运算符、比较运算符、逻辑运算符、三元运算符

数值运算符

		加（+），减（-），乘（*）、除（/）、取余数（%）、自增（变量++），自减（变量--）
		注意：1、+符号遇到字符串时拼接、连接
					2、独立运算：自增（自减）符号在前（++a）或者在后（a++）都没有区别
					3、混合运算(a=1;b=++a或者b=a++)：和其他变量放在一起结果就产生不同的结果：
					前++a：变量a自己加1，将加1后的结果赋值给b，也就是说a先计算。a和b的结果都是2。
					后a++：变量a先把自己的值1，赋值给变量b，此时变量b的值就是1，变量a自己再加1。a的结果是2，b 的结果是1。

赋值运算符

赋值运算就是将右边的值赋值给右边的变量
等于（=）、加等于（变量+=）、减等于（变量-=）、乘等于（变量*=）、除等于（变量/=）、取模等于（变量%=）		

比较运算符

比较运算符是比较两个数据（A、B）之间是否相等，返回结果是布尔值true或者false
相等（A==B）、小于（A<B）、大于（A>B）、小于等于（A<=B）、大于等于（A>=B）、不等于（A!=B）

逻辑运算符

逻辑运算符是连接两个布尔类型结果运算符，运算结果都是布尔类型true或者false
逻辑与（(true && true)）、逻辑或（(true || true)）、取反（!false）
逻辑运算符包括：
 && 短路与 1. 两边都是true，结果是true 2. 一边是false，结果是false 短路特点：符号左边是false，右边不再运算 
 || 短路或 1. 两边都是false，结果是false 2. 一边是true，结果是true 短路特点： 符号左边是true，右	边不再运算
 ！ 取反 1. ! true 结果是false 2. ! false结果是true

三元运算符

三元运算符格式：
	数据类型 变量名 = 布尔类型表达式？结果1：结果2
三元运算符计算方式： 
布尔类型表达式结果是true，三元运算符整体结果为结果1，赋值给变量。
布尔类型表达式结果是false，三元运算符整体结果为结果2，赋值给变量。

方法

方法定义：

方法：方法就是将一个功能抽取出来，把代码单独放置在大括号里，形成一个单独的功能
定义方法的两个明确：
1、明确返回值类型
2、明确参数列表
修饰符 返回值类型 方法名（参数列表）{
					代码块
					return 返回值；
		}
注意事项：
	1、方法定义在类中方法外
	2、方法里面不能定义方法
	3、return结果；这里的“结果”在开发中，我们正确叫法成为方法的返回值
	4、方法的参数为基本类型时,传递的是数据值. 方法的参数为引用类型时,传递的是地址值.

方法的调用：

定义方法后方法是无法自己执行的，必须通过调用才能运行 ；

public static void main(String[] args) {
    //调用被定义的方法
    test_addString();
    }
    //定义被调用的方法
    public static void test_addString(){
        //保持原有的字符不变的情况下新增字符
        String s1="ccc";
        s1+="d";
        System.out.println("s1 = " + s1);
    }

流程控制语句

流程控制语句类型：

判断语句if else、选择语句Switch、for循环语句、while循环语句、do while循环语句、跳出语句break，continue

判断语句 if else：

定义：判断表达式结果是true还是false；如果是true执行语句体，如果是false不执行语句体：

第一种格式：if

定义：判断表达式结果是true还是false；如果是true执行语句体，如果是false不执行语句体：
if（表达式）{

语句体

} 

public static void test_if(){
        int a=2;
        if (a>1){
            System.out.println("表达式结果为true是执行这个语句" );
        }
    }

第二种格式：if…else

定义：判断表达式结果是true还是false；如果是true执行语句体1，如果是false执行语句体2
if（表达式）{

语句体1

} else{

语句体2

}	

 public static void test_if_else(){
        int a= 2;
        if (a==1){
            System.out.println("表达式结果为true是执行这个语句" );
        }else {
            System.out.println("表达式结果为false是执行这个语句" );
        }
    }

第三种格式：if…else if…else
定义：判断表达式结果是true还是false；表达式1如果是true执行语句体1，如果是false执行表达式2
if（表达式1）{

语句体1

} else if(表达式2){

语句体2

}else
{
语句体3

}

public static void test_if_elseif_else(){
        int a=2;
        if (a>1){
            System.out.println("表达式1结果为true是执行这个语句" );
        }else if (a==1){
            System.out.println("表达式2结果为true是执行这个语句" );
        }else {
            System.out.println("表达式2结果为false是执行这个语句" );
        }
    }

if语句与三元运算符

if判断语句是可以和三元运算互换的

public static void if_TernaryOperation(){
        int a=1;
        int b=2;
        int c;
        if (a>b){
            c=a;
        }else {
            c=b;
        }
        //上述功能改为三元运算
        c=a>b?a:b;
    }

选择语句 Switch

定义：Switch选择语句首先计算出表达式的值，其次和case进行比较，一旦有对应的值就会执行case里面的语句块，执行过程中遇到break就会结束；最后在所有的case里找不到对应的值就会执行default语句然后结束程序；
注意：Switch表达式的数据类型可以是byte，short，int，char，enum（枚举），JDK7后可以接收字符串。
格式：
Switch (表达式){
case 常量值1：
语句体1；
break；
case 常量值2：
语句体2；
break；
......
default：
语句体N+1
break；
}

public static void test_switch(){
        int a=1;
        switch (a+1){
            case 1:
                System.out.println("执行性case1语句块");
                break;
            case 2:
                System.out.println("执行case2语句块");
                break;
            default:
                System.out.println("执行default语句块");
                break;
        }
    }

循环语句

for循环语句

定义：循环语句可以在满足条件下反复执行一段代码，这段被执行的被执行的代码称之为循环语句体，
当反复执行循环语句体时，需要合适的时候吧循环判断条件修改为false，从而结束循环，否则会一直执行下去形成死循环。
格式：
for（初始表达式；布尔表达式；进步表达式）{
循环语句体
}

public static void test_for(){
        int sum=0;
        for (int i = 1; i <=100 ; i++) {
            if(i%2==0){
                sum+=i;
            }
        }
        System.out.println(sum);
    }

while循环

格式：
初始表达式
while（布尔表达式）{
循环语句体；
进步表达式式；
}

public static void test_while(){
        int sum=0;
        int i=1;
        while (i<=100){
            if(i%2==0){
                sum+=i;
            }
            i++;
        }
        System.out.println(sum);
    }

do…while循环

 格式：
 初始表达式；
 do{
循环语句体；
进步表达式；
}while（布尔表达式）

public static void test_do_while(){
        int i=1;
        int sum=0;
        do {
            if(i%2==0){
                sum+=i;
            }
            i++;
        }while (i<=100);
        System.out.println("sum = " + sum);
    }

for循环与while的区别

1、控制条件的那个变量，在for循环结束后就不能再被访问到，而while循环结束还可以继续使用
2、在已知循环数的时候推荐使用for，循环此时未知的时候推荐使用while

跳出语句：

break：使用场景终止switch或者循环

		1、在选择结构switch语句中 
		2、在循环语句中 
		3、离开使用场景的存在是没有意义的

 public static void test_break(){
        for (int i = 0; i <5 ; i++) {
            if(i==3){
                System.out.println("i=2时执行这个语句块break跳出循环");
                break;
            }
        }
    }

continue：使用场景结束本次循环，继续下一次循环

public static void test_continue(){
        for (int i = 0; i <10 ; i++) {
            if (i == 3) {

                System.out.println("i等于3时continue跳过3继续下一次循环");
                continue;
            }
            System.out.println("i = " + i);
        }
    }

数组

数组定义方式一：

数组存储的数据类型 [] 数组名称 = new 数组存储的数组数据类型[长度]
注意：数组的长度一旦指定就不可以更改

int [] a =new int[10];

数组定义方式二：

数据类型[] 数组名称=new 数据类型[]{元素1，元素2，元素3。。。}

String[] b =new String[]{"a","b","c"};

数组的定义方式三：

数据类型[] 数组名称={元素1，元素2，元素3。。。。}

char[] c = {'a','b','c'};

数组的访问：

索引：每个存储到数组的元素都会有自动拥有一个编号，从0开始，这个编号称为数组索引（index），可以通过数组的索引访问到数组中的元素。
格式：数组名[索引]
数组的长度属性：每个数组都有长度，而且还是固定的，java中赋予了数组的一个属性，可以获取到数组的长度
【数组名.length】，属性length执行的结果为数组的长度，int类型结果，最大索引值为 数组名.length-1。
注意：
1、数组元素不为空时可以通过索引修改数组元素
2、数组元素为空时可以通过索引添加数组元素

c[0]//取出的值就是a
c.length//返回结果是3

数组遍历：

定义：数组遍历就是将数组中每个元素都分别取出来

 public static int test_arr(int[] arr){
        for (int i = 0; i <arr.length ; i++) {//for循环的布尔表达式中使用数组长度length遍历所有元素
            System.out.println("arr = " + arr[i]);
        }
        return arr[1];
    }

数组作为方法的参数与方法返回值：

数组作为方法参数传递，传递的参数是数组内存地址
数组作为方法的返回值，返回的是数组的内存地址
注意：方法的参数为基本类型时,传递的是数据值. 方法的参数为引用类型时,传递的是地址值.

public static int[] test_arr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int sum = arr[0];
            if (arr[i] > sum) {
                sum = arr[i];
            }
            System.out.println("sum = " + sum);
        }
        return arr;
    }

类

类的定义与格式：

类：属性、行为
属性：是指事物的状态信息。
行为：是指事物能做什么。
public class 类名{
成员变量
成员方法
}
注意：
1、成员变量就是类的属性
2、成员方法就是类的行为
3、定义类就是定义类的成员，包括成员变量和成员方法
4、成员变量：跟定义变量一样，只不过成员变量在类里面、方法外
5、成员方法：跟定义方法一样，只不过要把static去掉

public class String_s {
    String aAA="";
    public  int[] test_arr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int sum = arr[0];
            if (arr[i] > sum) {
                sum = arr[i];
            }
            System.out.println("sum = " + sum);
        }
        return arr;
    }
   }

对象的调用

格式：
类名 对象名=new 类名（）
使用对象访问类中的成员
对象名.成员变量
对象名.成员方法（）

public class test_calss {
    /*定义类*/
    String str="str是成员变量";
    public void test_mothod(){
        System.out.println("test_mothod是成员方法");
    }
}

public class test_mode {
    /* 测试类 */
    public static void main(String[] args) {
        test_calss test_M=new test_calss();
        System.out.println(test_M.str);
        test_M.test_mothod();
    }
}

封装

定义及格式

封装：将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问

封装的步骤：

1、使用private关键来修饰成员变量的属性
2、对需要访问的成员提供一对setxx()、getxx()方法

封装操作：

1、private是权限修饰符，代表最小权限
2、private可以修饰成员变量与成员方法
3、被private修饰过的成员变量成员方法只能在本类中才能被访问

private使用格式：

private 数据类型 变量名
private 数据类型 方法名

public class test_calss {
    /*private使用及访问*/
    private String Str;
    public void setStr(String str) {
        Str = str;
    }
    public String getStr() {
        return Str;
    }
   }

封装优化1–this关键字

this含义：
this代表所在类当前对象的引用（地址值），即对象自己的引用
注意 ：方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁。

public class test_calss {
    /*定义类*/
    private String Str;
    private int Int;
    public void setStr(String str) {
        this.Str=str;
    }
    public String getStr() {
        return Str;
    }
    //注意：方法中只有一个变量名时，默认也是使用 this 修饰，可以省略不写。

封装优化2–构造方法

构造方法的定义及格式：
定义：
1、当一个对象被创建时，构造方法用来初始化该对象，给对象的成员变量赋予初始值。
2、构造方法与类名相同，没有返回值，并且不需要返回值类型，甚至不需要void
3、类被调用时会默认一个无参构造方法
4、构造方法是可以重载的，既可以定义参数，也可以不定义参数。
格式：
修饰符 构造方法名（参数列表）{
方法体
}

public class test_calss {
    /*定义类*/
        /*private使用及访问*/
        private String Str="Str是私有变量";
        //无参构造方法
    public test_calss(){}
    //有参构造方法
    public test_calss(String S){
        this.Str=S;
    }
   }

Scanner类

定义：一个可以解析基本类型和字符串的简单文本扫描器
格式：
数据类型 变量名 =new 数据类型（参数列表）；
操作：
1、导包：import 包名.类名；java.util.Scanner；
2、创建对象：Scanner  sc=new Scanner(System.in);
3、创建接收键盘输入变量：String srt=sc.nextLine();
注意：system.in系统输入指的通过键盘录入数据。

public class test_scanner {
    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);
        String str= sc.nextLine();
        System.out.println("str = " + str);
    }
}

random类
定义：random生成一个随机数
查看类java.util.Random ：该类需要 import导入使后使用。
查看构造方法 public Random() ：创建一个新的随机数生成器。
查看成员方法 public int nextInt(int n) ：返回一个伪随机数，范围在 0 （包括）和 指定值 n （不包括）之间的 int 值

import java.util.Random;
 public class Demo01_Random { 
 public static void main(String[] args) { 
 Random r = new Random();
  for(int i = 0; i < 3; i++){ //3. 随机生成一个数据 
  int number = r.nextInt(10); //4. 输出数据 
  System.out.println("number:"+ number); 
  		} 
 	} 
}