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){//可变参数要写在参数列表的末尾

}