01.Java基础语法，01.java语法

01.开发环境搭建

搭建开发环境 1. JVM   Java Virtual Machine Java虚拟机 ： 用于与操作系统进行交互 JRE   Java Runtime Enviroment Java运行环境： JVM  +    Java核心类库 JDK  Java Development Kit Java开发工具包 ： JRE  +  Java开发工具集（java.exe  javac.exe  javadoc.exe） 2. ①下载安装JDK ②通过命令提示符到JDK安装路径的bin路径下，执行 javac ③配置path环境变量：JDK安装路径的bin路径下         流程：先在当前路径下找是否有 javac.exe，若没有再到 path 环境变量中从前往后依次查找         目的：在任意路径下执行 javac    ④JAVA_HOME :  JDK安装根路径 五、开发第一个应用程序 步骤： ①创建一个 .java 结尾的文件，被称为 java源文件。 如：  【HelloWorld.java】     public class HelloWorld{         public static void main(String[] args){             System.out.println("HelloWorld！");         }     } ②编译： 通过 javac + 源文件名称 命令进行编译， 生成一个或多个 .class 字节码文件。  如：【javac HelloWorld.java】 ③运行： 通过 java + .class 字节码文件名 命令进行运行。（JVM会将一个或多个.class 字节码文件加载到内存中）。   如：【java HelloWorld】 2. 开发第一个应用程序的注意： ①以  .java 结尾的文件，被称为 java源文件。 ②一个 .java 源文件中可以有多个类，但是，只能有一个 public 修饰的类 ③public 修饰类的名称必须与 .java 源文件名称一致 ④每条语句以 “;” 结束 ⑤Java 严格区分大小写 六、注释语句: 不会被JVM解释执行的语句 //单行注释 /*     多行注释：不能嵌套 */ /**     文档注释： 可以通过  javadoc -d mydoc -author -version HelloWorld.java 命令生成说明文档 */

02.Java基础语法

一、 标识符：凡是自己命名的地方都叫标识符。 如： 包名、类名、接口名、方法名、变量名、常量名 关键字：被Java赋予了特殊含义的单词。 1. 命名的规则 （必须遵守，若不遵守编译不能通过）      命名规则： 字母（ A-Z，a-z）， 数字（ 0-9） ， “$”和 下划线 "_"        注意： ①数字不能开头 ②不能使用java关键字和保留字，但是可以包含关键字和保留字 ③Java严格区分大小写，但是长度无限制。 2. 命名的规范 （可以不遵守，但是会收到鄙视） ①包名： 所有字母都小写。 如： xxxyyyzzz ②类名、接口名：每个单词首字母都大写。如： XxxYyyZzz ③方法名、变量名： 第一个单词的首字母小写，其余单词首字母都大写。如： xxxYyyZzz ④常量名： 所有字母都大写，每个单词之间以 "_" 分隔。 如： XXX_YYY_ZZZ 二、 变量：用于保存数据 局部变量  &  成员变量 1. 变量的定义格式 a.数据类型   变量名   =   值;        如：int a=1; b.数据类型   变量名 ;    变量名   =   值;   如：int a;a=1; 2. 变量的概念：     ①在内存中开辟一块内存空间     ②该空间有名称（变量名）有类型（数据类型）     ③变量可以在指定的范围内不断的变化 3. 变量的注意：     ①作用域：变量作用在所属的那对 {}  内     ②局部变量在使用前必须赋初始值     ③先声明，后使用 局部变量  &  成员变量的初始化 成员变量：类中方法外，存放在堆中 局部变量：方法定义中或者方法声明上，存放在栈中 1. 对于类的成员变量，不管程序有没有显式的进行初始化，Java虚拟机都会先自动给它初始化为默认值。 2. 局部变量声明之后，Java虚拟机就不会自动给它初始化为默认值，因此局部变量的在参与运算之前必须初始化。 三、进制之间的转换（了解） 四、变量的数据类型 基本数据类型（8种）：     整型：               字节                  byte           1                 short           2                  int               4                  long           8 布尔型：boolean 1 字符型：char 2 浮点型：float 4                 double        8        引用数据类型：     |---类(class)        |---接口(interface)     |---数组([])     |--- String 字符串 声明变量的注意：     ①整性默认是int，浮点型默认是double     ②使用long要加 L 或 l ，使用 float 要加 F 或 f 。 如：long a=15L ; float b=15.6f;      五、变量的运算 数据类型的转换： 自动类型转换（自动升级）：小容量转大容量。（系统自动完成）     ①byte  short  char   --->   int  --->  long  ---> float  --->  double     ②byte short  char  三者之间不进行运算，若运算自动提升成 int 再做运算             char c1 = 'A';             char c2 = 'B';             int i = c1 + c2;     ③boolean 不参与运算     ④String与任何基本数据类型使用连接符(+) 进行运算，都将自动串接成 String 类型 强制类型转换：目标数据类型   变量名=（目标数据类型）（被转换的数据）（小<===大）                      六、运算符 算数运算符 :  +   -   +   -   *   /  %   前++  后++  前--  后--   +(连接符) //除法 int a = 12; int b = 5; int c = a / b; //2 //取模 int c = 12 % 5; //前后++ int i = 10; int j = i++; System.out.println(i);//11 System.out.println(j);//10 System.out.println(++i); int i = 10; i = i++; //10 在前（i++）：先赋值，后自增； 在后（++i）：先自增，后赋值； 赋值运算符：  =   +=   -=   *=   /=   %= int i = 10; i += 5; //i = i + 5; System.out.println(i); //15 【面试题】 short s = 5; s = s + 1;//编译？  NO s += 1; //编译？ YES      s = (short)(s + 1); （+=，-=，/=等）扩展的赋值运算符其实隐含了一个强制类型转换。 比较运算符（关系运算符） :  ==    !=  >    <    >=   <=  （运算后结果都为 boolean 型） int a = 10; int b = 20; boolean b1 =  a == b; 逻辑运算符： && -短路与   ||-短路或   !-逻辑非    &-逻辑与   |-逻辑或   ^-异或  （运算后结果都为 boolean 型） //需求：判断一个数是否大于10 小于20 int a = 10; //10 < a < 20; 错误的做法 boolean b2 = a > 10 && a < 20; 【面试题】 && 和  &  的区别？ && ： 称为短路与，当左边表达式结果为 false 时，右边表达式将不再运算 & ： 是位运算符，当用于逻辑运算时，无论左边表达式结果为true还是false，右边都运算 位运算符 ：  ~    |   &  ^    <<  >>   >>>   注意：没有 <<< 三元运算符（三目运算符）     条件表达式  ？  表达式1  :  表达式2;     ①当条件表达式结果为 true 时，执行表达式1 ，否则执行表达式2     ②表达式1和表达式2的结果类型需要保持一致！

一、流程控制： 顺序结构 分支结构     条件判断：             if(条件表达式){                 //当条件表达式结果为 true 时，需要执行的语句                        }             if(条件表达式){                 //当条件表达式结果为 true 时，需要执行的语句                        }else{                 //当条件表达式结果为 false 时，需要执行的语句                        }             if(条件表达式1){                 //当条件表达式1 结果为 true 时，需要执行的语句                        }else if(条件表达式2){                 //当条件表达式2 结果为 true 时，需要执行的语句                        }else if(条件表达式3){                 //当条件表达式3 结果为 true 时，需要执行的语句             }             ……             else{                 //当上述条件表达式结果都为 false 时，需要执行的语句                        }             注意：                 ①当某个条件表达式结果为true， 执行相应的语句，其他 else if 将不再执行                 ②if-else 语句可以嵌套的                 ③条件表达式的结果必须是boolean类型     选择结构：             switch(表达式){                 case 值1 :                     //执行的语句                     break;                 case 值2 :                     //执行的语句                     //break;                 case 值3 :                     //执行的语句                     break;                 ……                 default :                     //执行的语句                     break;                        }             注意：                 ①表达式结果的数据类型只能是一个整数表达式或者枚举常量，整数表达式可以是int基本类型或Integer包装类型,即 byte   short  char  int  枚举   String(jdk1.7后)                 ②表达式结果的数据类型要与case后值的类型需要保持一致！                 ③default 是可选的                 ④break 也是可选的，若与某个case后的值匹配成功，依次向下执行，直到遇到break为止。'                 ⑤case 后只能写常量值，不能写表达式                 //需求：若一个数大于2 小于5  打印 “2-5”                 int i = 2;                 switch(i){                     case 1:                         System.out.println("一");                         break;                     case 2:                     case 3:                        case 4:                                                case 5:                         System.out.println("2-5");                         break;                                                    } 循环结构： ①初始化值 ②循环条件 ③迭代条件 ④循环体     for(① ; ② ; ③){         ④        }     ①②④③②④③②④③②……④③②     ①     while(②){         ④         ③     }     ①     do{         ④         ③     }while(②);    while 和 do-while 的区别？ while ： 先判断循环条件，再执行循环体 do-while : 先执行循环体，再判断循环条件。（至少执行一次）    二、嵌套循环： 一个循环充当了另一个循环的循环体 打印100以内的质数： boolean flag = true; for(int i = 2; i <= 100; i++){     for(int j = 2; j < i; j++){         if(i % j == 0){             flag = false;             break;         }     }     if(flag){         System.out.println(i);        }     flag = true; } 三、特殊流程控制语句 break: 结束“当前”循环。当用于switch-case语句时，用于结束当前 switch-case 语句 continue:  结束“本次”循环 label:for(int i = 0; i < 100; i++){     for(int j = 0; j < 100; j++){         if(j == 13){             System.out.println(j);             break label;         }     } }

03.方法的声明和使用

一、方法：也叫函数，是一个功能的定义。是一个类中最基本的功能单元 //需求： 计算一个数 * 2 + 1 的结果 int a = 10; System.out.println(a * 2 + 1); a = 5; System.out.println(a * 2 + 1); a = 8; System.out.println(a * 2 + 1); 1.方法的格式： 修饰符  返回值类型  方法名(参数列表){     //功能语句     return 返回值; } 返回值类型：说明方法运行后有结果，那个结果的数据类型。 参数列表：就是局部变量，可以有0个或多个，每个参数之间以 “,” 分隔 return ： 用于结束当前方法 返回值：方法运行结束后，返回具体结果的值 public static int result(int a){ //形式参数： 用于接收调用者传递的实际参数     return a * 2 + 1; } result(10);//实际参数 2. 方法的注意： ①“返回值类型”与 “返回值”的数据类型需要保持一致 ②调用方法通过方法名和参数列表，注意方法名和参数列表（参数的个数、参数的类型）必须一致 ③若声明了“返回值类型”说明该方法运行后有结果，若调用者需要用到该结果    可以声明同类型变量接收。 ④若方法运行结束后，不需要返回任何结果给调用者时，方法“返回值类型”处声明为 void     void ： 表示没有返回值 ⑤方法中只能调用方法，不能声明其他方法 3. 声明方法的两点明确 ①方法是否需要返回结果给调用者     明确是否需要返回值类型，返回值类型是什么 ②方法是否有未知的数据参与运算     明确是否需要参数列表，需要几个 参数列表返回值 二、跨类调用方法：     通过“类名.方法名" 方式调用。 （暂时使用static修饰的方法为例）

一、参数的值传递 基本数据类型：将基本数据类型作为参数，传递给方法，方法运行结束后，原值不会发生改变         //改变两个数的值         public static void add(int a, int b){             a += 1;             b += 2;                }         public static void main(String[] args){             int a = 10;             int b = 20;             add(a, b);             System.out.println("a=" + a + " b=" + b);//a=10, b=20         } 引用数据类型：

方法重载 Overload ： 前提：在同一个类中 ①方法名相同 ②参数列表不同（参数的个数、参数的类型） 注意：与返回值类型无关 public void show(char c, int a){} public void show(int a, char c){} public void show(int a, char c, double d){} public void show(String str, int a){} public void shows(char c, int a){}

方法重写 Override ： 前提：在子类和父类中
   子类与父类方法声明相同的方法

1、在子类中可以根据需要对从基类中继承来的方法进行重写。

2、重写的方法和被重写的方法必须具有相同方法名称、参数列表和返回类型。

3、重写方法不能使用比被重写的方法更严格的访问权限。

class Person{
    private int age;
    private String name;
    
    public void setAge(int age){
        this.age = age;
    }
    public void setName(String name){
        this.name = name;
    }
    public int getAge(){
        return age;
    }
    public String getName(){
        return name;
    }
    
    public String getInfo(){
        return "Name is:"+name+",Age is "+age;
    }
}
class Student extends Person{
    private String school;
    
    public void setSchool(String school){
        this.school = school;
    }
    public String getSchool(){
        return school;
    }
    public String getInfo(){
        return "Name is:"+getName()+",Age is "+getAge()+",School is:"+school;
    }
}
public class TestOverRide{
    public static void main (String args[]){
        Student student = new Student();
        Person person = new Person();
        person.setAge(1000);
        person.setName("lili");
        
        student.setAge(23);
        student.setName("vic");
        student.setSchool("shnu");
        
        System.out.println(person.getInfo());
        System.out.println(student.getInfo());
    }
}

04.声明和使用数组

一、数组：用于批量保存一类数据。是引用数据类型之一。
    //变量的格式 ： 数据类型   变量名  =   值;     int j = 0;     int j;     j = 0;

2. 声明数组 int[] scores; String[] names; Person[] persons;
3.为数组初始化并赋值 //静态初始化： 初始化操作和赋值操作同时进行 scores = new int[]{0,1,2,3,4,5};
//动态初始化：初始化操作和赋值操作分开进行 names = new String[5]; //{null, "张三", null, "李四", null}
names[1] = "张三"; names[3] = "李四";
4. 获取数组中的元素 String str = names[0]; System.out.println(str); System.out.println(names[1]); System.out.println(names[2]); System.out.println(names[3]); System.out.println(names[4]);
5. 遍历数组的两种方式 方式一：使用普通for循环遍历数组
for(int i = 0; i < names.length; i++){     System.out.println(names[i]); }
方式二：使用增强for循环遍历数组
for(被遍历数组中元素的数据类型  变量名 : 被遍历的数组){
}
for(String s : names){     System.out.println(s); }
6. 数组的注意：     ①无论是静态初始化还是动态初始化必须指明长度     ②数组中每个元素都有索引值（下角标、下标），索引值从0开始，到 数组的长度 - 1     ③数组的属性： length  用于获取数组的长度   
7. 数组的默认值
基本数据类型： byte shor int ---> 0 long  ---> 0L float ---> 0.0F double  ---> 0.0D char ---> '\u0000' boolean ---> false
引用数据类型： ---> null     |-- 类(class)     |-- 接口（interface）     |-- 数组（[]）
二、二维数组
//声明一个二维数组 int[][] arr;
//为二维数组初始化并赋值 //静态初始化：初始化和赋值操作同时进行 arr = new int[][]{ {1,2,3}, {4,5,6}, {7,8} }
//动态初始化 //动态初始化-1 arr = new int[5][6]; //{ {0,0,11,0,0,0}, {0,0,0,0,0,0}, {0,0,0,0,0,0}, {0,0,0,15,0,0}, {0,0,0,0,0,0} }
arr[0][2] = 11; arr[3][3] = 15;
//动态初始化-2 arr = new int[5][]; //{ null, {0,11,0}, null, {0,0,0,22,0}, null };
arr[1] = new int[3]; arr[3] = new int[5];
arr[1][1] = 11; arr[3][3] = 22;

//遍历二维数组 for(int i = 0; i < arr.length; i++){     for(int j = 0; j < arr[i].length; j++){         System.out.prin     for(int a : as){t(arr[i][j] + "\t");     }
    System.out.println(); }

for(int[] as : arr){     for(int a : as){         System.out.print(a + "\t");        }     System.out.println(); }

三、用于操作数组的工具类：   java.util.Arrays;

四、命令行参数
通过： java HelloWorld  abc ddd eee "Jane Smith"
public static void main(String[] args){     for(int i = 0; i < args.length; i++){         System.out.println(args[i]);     } }
五、可变参数
//需求：计算两个整数的和 /*public int add(int a, int b){     return a + b; }
public int add(int a, int b, int c){     return a + b + c; }*/
/*public int add(int[] arr){//可变参数与数组参数之间不能构成重载     int sum = 0;     for(int i = 0; i < arr.length; i++){         sum += arr[i];     }     return sum; }*/
public int add(int ... args){ //当调用方法时，可以传递0个或多个 int 型实际参数     int sum = 0;     for(int i = 0; i < args.length; i++){         sum += args[i];     }     return sum; }
public int add(String str, int ... args){//可变参数要写在参数列表的末尾
}