JAVA基础知识笔记

一、入门

注释

注释：出现在源程序中，解释说明。
分为：
单行注释
多行注释
javadoc注释：被javadoc.exe工具提取形成帮助文档，比较专业的注释。

类体中不能直接编写java语句，除了声明变量以外。

class和public class

一个java源文件中可以定义多个class，一个java源文件当中不一定有public class,但public class定义的话，必须只能有一个，且名称得和源文件名称一致。

二、基本知识

标识符

在java源程序中凡是程序员有权利自己命名的都是标识符。

标识符可以标志的元素：
变量名
方法名
类名
接口名
常量名
……

标识符的命名规则：
一个合法的标识符必须由下划线、字母、数字和美元符号组成。
不能数字开头。
严格区分大小写。
关键字不能作为标识符。
理论上无长度限制，但是最好不要太长。

标识符的命名规范：
只是一种规范，不遵守规范，编译器不会报错。
最好见名知意。
遵守驼峰命名方式：UserService
类名、接口名：首字母大写，后面每个单词首字母大写。
变量名、方法名：首字母小写，后面每个单词首字母大写。
常量名：全部大写。

关键字

Java中关键字都是小写的。

字面值

字面值：10、100、“abc”、‘a’、true、false
字面值就是数据，是源程序的组成部分之一。
数据在计算机中是有类型的：整型、浮点型、字符串型、字符型、布尔型。

注意：
Java语言当中所有字符串必须使用双引号，字符必须使用单引号。

变量

关于Java语言中的变量：
1、什么是变量？
数据会占用空间，给空间命名一个值，比如a，那么a就是一个变量，本质上是内存中的一块空间，该空间有数据类型、名字、字面值。
变量是内存中存储数据的基本单元。

2、数据类型的作用？
不同的数据有不同的数据类型，分配的底层空间大小不同。
数据类型是指导程序在运行阶段应该分配多大的空间。

3、变量要求：变量中存储具体的数据必须和变量名的数据类型一致，否则会报错。

4、语法格式：
数据类型 变量名；

5、变量声明之后如何赋值？
语法格式：
变量名=字面值；

要求：字面值的数据类型必须和变量的数据类型一致。
等号是一个运算符，叫做赋值运算符，赋值运算符先运算等号右边的表达式。

6、声明和赋值可以放到一起完成。
int i=10;

7、变量赋值之后，可以重新赋值、变量的值可变化。

8、有了变量之后，内存空间得到了重复的使用。

9、通常访问一个变量包括两种形式：
（1）读取变量中保存的具体数据 get/获取
（2）修改变量中保存的具体数据 set/设置

10、变量在一行上可以声明多个。
int a,b,c;

11、变量必须先声明再赋值，才能访问。

在方法体中代码是从上至下执行。在同一个作用域中变量名不能重名，但可以重新赋值。

变量的分类：
（1）局部变量：在方法体中声明
（2）成员变量：在方法体外声明

作用域

1、什么是作用域？
变量的作用域就是变量的有效范围。在范围之内可以访问，出了范围就不能访问。

2.一句话：
作用域是出了大括号就不认识了。

数据类型

1、数据类型的作用？
程序当中有很多数据，每一个数据都是有相关类型的，不同数据类型不同，作用是指导JVM在运行程序时给该数据分配多大的空间。

2、分类
基本数据类型
引用数据类型

3、关于基本数据类型：
（1）整数型
byte,short,int,long
（2）浮点型
float,double
（3）布尔型
boolean
（4）字符型
char

4、字符串不属于基本数据类型，属于引用数据类型

5、占用空间大小（单位：字节）
byte 1
short 2
int 4
long 8
float 4
double 8
boolean 1
char 2

6、计算机在任何情况只认识二进制。
现代的计算机底层采用交流电方式，接通和断开就两种状态。

7、什么是二进制？
满二进一

8、字节：
1 byte = 8 bit
一个比特位表示一个二进制位，1/0

9、整数型当中的byte类型，占用一个字节，所以byte类型的数据占用8个比特位。
最大值：01111111
最小值：11111111
0表示正号，1表示负号。

10、进制转换

11、计算机只认识二进制，那么计算机怎样认识现实世界中的文字？
人为干涉，提前制定好转换关系，即字符编码。
ASCII
乱码的出现是编码和解码没有用同一套字典。

字符编码
ASCII
GB2312/GBK
unicode
Java语言中标识符可以用中文。

12、8种基本数据类型取值范围：

关于Java语言中的char类型
转义字符 \出现在特殊字符前会将特殊字符转换成普通字符
换行字符 \n
制表符 \t
在Java中两个反斜杠代表普通的反斜杠
’ 代表普通的单引号字符
" 普通双引号

JDK中自带的native2ascii.exe命令，可以将文字转换成unicode编码形式。
反斜杠u联合起来后面的一串数字是某个文字的unicode编码。

关于Java中的整数类型
1、Java语言中的”整数型字面值“被默认当作int类型来处理。要让这个整数型字面值被当作long类型来处理的话，需要在整数型字面值后面加l/L.

2、java语言当中的整数型字面值有三种表示方式：
第一种方式：十进制【是一种缺省默认的方式】
第二种方式：八进制【在编写八进制整数型字面值的时候需要以o开始】
第三种方式：十六进制【在编写八进制整数型字面值的时候需要以ox开始】

关于Java中的浮点型
float 单精度【4个字节】
double 双精度【8个字节，精度较高】
相对来说，double精度太低，不适合做财务软件，涉及到钱的问题，要求精度较高，所以SUN公司提供了更高精度的引用数据类型：java.math.BigDecimal。

在Java语言中，所有的浮点型字面值默认被当作double类型处理，想要浮点型，需要在字面值后面添加F/f。

注意：
double和float在计算机中二进制存储的时候存储的都是近似值，在现实世界中有一些数字是无限循环的，在计算机中资源是有限的，用有限的资源存储无限的值所以是近似值。

关于布尔型数据类型
boolean
在Java语言中boolean类型只有两个值：true,false,没有其他值。不像c语言中，0和1可表示假和真。在底层存储的时候boolean类型占用一个字节，因为实际存储的时候false底层是0，true底层是1.

关于基本数据类之间的互相转换
1、八种基本数据类型中除布尔类型之外剩下七种类型之间都可以互相转换。

2、小容量向大容量转换称为自动类型转换，容量从小到大排序：byte<short(char)<int<long<float<double
char和short可表示的种类数量相同，但char可以取更大的正整数。

3、大容量向小容量转换为强制类型转换，需要加强制类型转换符，才能编译通过，但是在运行阶段可能损失精度。

4、当整数字面值没有超过byte,char,short的取值范围，可以直接赋值给byte,short,char。

5、byte,char,short做混合运算时，各自先转换成int类型再做运算。

6、多种数据类型混合做运算，先转换成容量最大的那种类型再做运算。

运算符

算术运算符

• 求和：+
• 相减：-
• 乘积：*
• 商：/
• 求余数【取模】：%
• 自加1：++，++出现在变量之后，先做赋值运算，再对变量中保存的值加1；出现在变量之前则先进行自加1运算，然后再进行赋值操作。
• 自减1：- -

关系运算符

• 大于 >
• 大于等于 >=
• 小于 <
• 小于等于 <=
• 等于 ==
• 不等于 !=

逻辑运算符

• & 逻辑与（两边算子都是true,结果才是true)

• | 逻辑或(两边算子只要有一个是true,结果就是true)

• ! 逻辑非(取反，单目运算符）

• ^ 逻辑异或（两边算子只要不一样就是true)

• && 短路与

• || 短路或

1、逻辑运算符要求两边的算子都是布尔类型，并且逻辑运算符最终的运算结果也是一个布尔类型。
2、短路与和逻辑与最终的运算结果是相同的，只不过短路与存在短路现象。
3、短路或和逻辑或最终的运算结果是相同的，只不过短路或存在短路现象。

从某个角度来看，短路与比逻辑与更智能，由于后面表达式可能不执行。

赋值运算符
包括两种:
基本的赋值运算符:

• =

扩展的赋值运算符:

• +=
• -=
• *=
• /=
• %=

1、先执行等号右边的表达式
2、注意以下代码：
byte i=10;
i+=5;等同于：i=(byte)(i+5);
3、重要结论：扩展类的赋值运算符不改变运算类型。

字符串连接运算符
关于java中的“+”运算符：
两个作用：

• 1、加法运算：两边都是数字。
• 2、字符串的连接运算：只要有一个数据是字符串，即连接运算，且运算结果是字符串类型。

三元运算符
也叫三目运算符或条件运算符
1、语法规则：
布尔表达式？表达式1：表达式2

2、执行规则：
布尔表达式为真，执行表达式1，为假，执行表达式2。

控制语句

接收用户接盘输入:从键盘到内存
创建键盘扫描器:

java.util.Scanner s=new java.util.Scanner(System.in);
String userInputContent=s.next();
int num=s.nextInt();

选择结构

• if，if…else
  关于Java语言中的if语句，属于选择结构，又被称为分支语句或条件控制语句。

1、if语句的语法结构：
第一种：
if(布尔表达式）{
java语句
}

第二种：
if(布尔表达式）{
java语句
}else{
java语句
}

第三种：
if(布尔表达式）{
Java语句
}else if（布尔表达式）{
Java语句
}else if（布尔表达式）{
Java语句
}
……

}

第四种：
if(布尔表达式）{
Java语句
}else if（布尔表达式）{
Java语句
}else if（布尔表达式）{
Java语句
}
……

}else{
Java语句
……
}
所有的控制语句都是可以嵌套使用的。但是该缩进的必须缩进。

if语句中只有一条语句的时候大括号可以省略。
例子:

public class IfTest01 {
    
    public static void main(String[] args) {
    
        double distance=15.0;
        if (distance<5.0){
    
            System.out.println("去吃午饭！");
        }else{
    
            System.out.println("不去吃午饭!");
        }
System.out.println("-----------------------");
//输出成绩等级.
        int grade=34;
        if (grade>100||grade<0){
    
            System.out.println("数据不合法!");
        }else if (grade>=90){
    
            System.out.println("A");
        }else if(grade>=80){
    
            System.out.println("B");
        }else if (grade>=70){
    
            System.out.println("C");
        }else if (grade>=60){
    
            System.out.println("D");
        }else{
    
            System.out.println("E");
        }
    }
}

例子:

//Created on 2021/2/15
//输入年龄,判断年龄处于哪个阶段.
public class IfTest02 {
    
    public static void main(String[] args) {
    
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        int age=scanner.nextInt();

        String string="老年";
        if (age<0||age>150){
    
            string="数据不合法!";
        }else if (age<=5){
    
            string="幼年";
        }else if (age<=10){
    
            string="少年";
        }else if (age<=18){
    
            string="青少年";
        }else if (age<=35){
    
            string="青年";
        }else if (age<=55){
    
            string="中年";
        }else if (age<=150){
    
            string="老年";
        }
        System.out.println(string);
    }
}

例子:

//Created on 2021/2/15
/*
判断当前的天气:当外面下雨的时候,下雨为1
        带雨伞:
        判断性别:
          男:带大黑伞,0
          女:带小花伞,
        当外面晴天的时候,晴天为2:
         判断天气温度:
           温度在30度以上:
             当性别为男:戴墨镜
             当性别为女:防晒霜
*/

public class IfTest03 {
    
    public static void main(String[] args) {
    
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        System.out.println("欢迎使用本系统,下面是一些说明:");
        System.out.println("--------------------------------------");
        System.out.println("说明1: 下雨天用数字1表示,晴天用数字2表示!");
        System.out.println("说明2: 数字0表示性别男,其他数字表示女!");
        System.out.println("说明3: 温度用数字表示!");
        System.out.println("-------------------------------------");

        System.out.print("请输入天气:");
        int num=scanner.nextInt();

        if (num==1){
    
            System.out.println("外面为雨天!");
            System.out.println("请输入性别:");
            int sex=scanner.nextInt();
            if (sex==0){
    
                System.out.println("性别为男,带大黑伞");

            }else{
    
                System.out.println("性别为女,带小花伞!");
            }

        }else if (num==2){
    
            System.out.println("外面为晴天!");
            System.out.println("请输入温度:");
            int temperature=scanner.nextInt();

            if (temperature>30){
    
                System.out.println("请输入性别:");
                int sex=scanner.nextInt();
                if (sex==0){
    
                    System.out.println("性别为男,带墨镜");

                }else{
    
                    System.out.println("性别为女,擦防护霜!");
                }
            }else if (temperature<=30){
    
                System.out.println("在家待着,玩什么玩儿,作业写完了吗?");
            }

        }else{
    
            System.out.println("对不起!输入天气状况有误!");
        }
    }
}

• switch
  关于switch语句:
  1、switch语句也属于选择结构，也是分支语句
  2、语法结构：

switch（int或string类型的字面值或变量）{
    
case int或string类型的字面值或变量；
Java语句；
……
break；
case int或string类型的字面值或变量；
Java语句；
……
break；
default：
Java语句
……
}

3、执行原理：
switch后面小括号当中的数据和case后面的数据进行一一匹配，匹配成功的分支执行。自上而下顺序执行。

4、匹配成功的分支执行，后面有break，执行，整个switch结束。

5、匹配成功分支执行，分支当中没有break语句的话，直接进入下一个分支执行（不进行匹配（，这种现象被称为case的穿透现象，提供break可避免穿透。

6、所有分支都没有匹配成功，当有default语句的话，执行default中的语句。

7、switch后面和case后面只能是int和string类型的数据，不能探测其他类型数据类型，当然其他类型也可以写在其后，不过会进行自动类型转换。

8、case可以合并。

int i=10;
switch（i）{
    
case 1：case 2：case 3：case 4
}

例子:

import java.util.Scanner;

//Created on 2021/2/16
/*接收用户输入，输入1为星期一
* 输入2为星期二
* ……
* */
public class Switch01 {
    
    public static void main(String[] args) {
    
        java.util.Scanner scanner=new Scanner(System.in);
        System.out.println("请输入数字:");
        int num =scanner.nextInt();
        switch (num){
    
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6:
                System.out.println("星期六");
                break;
            case 7:
                System.out.println("星期天");
                break;
                default:
                    System.out.println("输入数据不合法!");
        }
    }
}

例子:

import java.util.Scanner;

//Created on 2021/2/16
/*实现计算器中的+ - * / %
* 实现思路:
*    1.选择所有数据从键盘输入
*    2.使用switch进行判断
*    3.需要从控制台输入三次:第一个数字,运算符,第二个数字
* */
public class Switch02 {
    
    public static void main(String[] args) {
    
        Scanner scanner=new Scanner(System.in);
        System.out.println("欢迎使用简单计算器系统:");
        System.out.print("请输入第一个数字: ");
        int num1=scanner.nextInt();
        System.out.print("请输入运算符: ");
        String string=scanner.next();
        System.out.print("请输入第二个数字: ");
        int num2=scanner.nextInt();

        int result=0;

        switch (string){
    
            case "+":
                result=num1+num2;
                break;
            case "-":
                result=num1-num2;
                break;
            case "*":
                result=num1*num2;
                break;
            case "/":
                result=num1/num2;
                break;
            case "%":
                result=num1%num2;
                break;
                
        }

        System.out.println("运算结果: "+num1+" "+string+" "+num2+" "+"="+" "+result);
    }
}

循环结构
为什么会有循环结构?
在程序当中总有一些需要反复执行的代码,假设没有循环结构,那么这段代码需要反复编写.

• for
  语法结构:

for(初始化表达式;布尔表达式;更新表达式){
    
java语句,循环体
}

初始化表达式最先执行,且在整个过程中只执行一次.
判断表达式的结果:
true:执行循环体,执行更新表达式
false:循环结束

例子:

//Created on 2021/2/16
/*按阶梯型输出9*9乘法表
* 1*1=1  
2*1=2  2*2=4  
3*1=3  3*2=6  3*3=9  
4*1=4  4*2=8  4*3=12  4*4=16  
5*1=5  5*2=10  5*3=15  5*4=20  5*5=25  
6*1=6  6*2=12  6*3=18  6*4=24  6*5=30  6*6=36  
7*1=7  7*2=14  7*3=21  7*4=28  7*5=35  7*6=42  7*7=49  
8*1=8  8*2=16  8*3=24  8*4=32  8*5=40  8*6=48  8*7=56  8*8=64  
9*1=9  9*2=18  9*3=27  9*4=36  9*5=45  9*6=54  9*7=63  9*8=72  9*9=81  

* */
public class For01 {
    
    public static void main(String[] args) {
    
        for (int i=1;i<=9;i++){
    
            for (int j=1;j<=i;j++){
    
                System.out.print(i+"*"+j+"="+i*j+"  ");
                if (j==i){
    
                    System.out.println();
                }
            }
        }
    }
}

例子:

• while

语法结构:
while(布尔表达式){
循环体
}

布尔表达式为真,执行循环体
继续判断布尔表达式
……

• do…whlie
  执行语法结构：
  do{
  循环体
  ……
  }while（布尔表达式）；

控制循环的语句

• break
  1、翻译为“中断/折断”
  2、可以单独成为一条语句
  3、可以使用在switch语句中结束
  4、也可以用在循环语句中跳出循环
  5、默认情况下终止最近的循环
  6、也可用于指定中断某个循环
  break for1;

• continue
  1、表示继续
  2、continue;可为单独语句
  3、中止当前本次循环，跳到更新表达式
  4、也可“continue 循环名称；”

练习题

//Created on 2021/2/16
/*编写for循环语句找出1-1000中的素数，每8个换一行*/
public class Prime {
    
    public static void main(String[] args) {
    
        int count=0;
        for (int i=2;i<=1000;i++){
    
            boolean isPrime=true;
            for (int j=2;j<i;j++){
    
                if (i%j==0){
    
                    isPrime=false;
                }
            }
            if (isPrime){
    
                System.out.print(i+" ");
                count++;
                if (count==8){
    
                    System.out.println();
                    count=0;
                }
            }
        }
    }
}

运行结果展示：

三、方法

方法初步

方法定义在类体当中，在一个类中可以定义多个方法，编写的位置没有先后顺序。方法体中的代码从上至下执行。

方法体中不再定义方法！！！

使用方法代码得到了重复使用。

关于Java语言中的方法：
1、方法怎么定义？

[修饰符列表] 返回值类型 方法名（形式参数列表）{
    
方法体；
}

2、语法结构说明
2.1、关于修饰符列表？

• 可选项，不是必须的
• 目前可写成public static
• 方法的修饰符列表中有static的话，怎么调用这个方法：类名。方法名（实际参数列表）；

2.2、返回值类型
什么是返回值类型？
一个方法是可以完成某个特定的功能的，这个功能结束之后大多数都是需要返回最终执行结果的，执行结果可能是一个具体存在的数据，此处需指定具体类型。

也可结束之后不返回任何值，但必须编写void关键字。

返回值类型是void的时候，在方法体中不能编写“return 值；”这样的语句，但是可编写“return；”这样的语句。

只要return·关键字执行，return所在的语句所在的方法结束（不是JVM结束，而是return所在方法结束）

形式参数列表：简称形参

• 是局部变量
• 个数是0-n个
• 多个形参之间用逗号隔开
• 形参中起决定性作用的是形参的数据类型，形参的名字就是局部变量的名字。
• 方法调用的时候，实际给这个方法传递的真实数据被称为实际参数，简称实参。

3、方法怎么调用？
方法只定义不去调用是不会执行的，只有在调用的时候才会执行。

方法在执行过程当中，在JVM中内存如何分配？
1、方法只定义，不调用，是不会执行的，并且在JVM中也不会给该方法分配运行所属的内存空间。

2、在JVM中内存划分上有这样的三个主要空间：

• 栈内存
• 堆内存
• 方法区内存

3、关于栈数据结构

• 栈：stack，是一种数据结构

• 数据结构反映的是数据的存储形态

  栈帧永远指向栈顶元素
  栈顶元素处于活跃状态，其他元素静止

  术语：
  压栈/入栈/push
  弹栈/出栈/pop

栈数据结构存储特点：先进后出，后进先出

4、方法执行的时候代码片段在哪里？

• 方法代码片段属于.class字节码文件的一部分，字节码在类加载的时候，将其放到了方法区中。所以JVM的三块主要的内存空间中方法区内存最先有数据。
• 代码片段虽然在方法区中只有一份，但可以重复调用。每一次调用这个方法的时候，需要栈内存中分配方法运行的所属内存空间。

5、方法在调用的瞬间，会给栈内存分配内存空间，会在栈中发生压栈动作，方法执行结束后，该方法分配的内存全部释放，此时发送弹栈动作。

6、局部变量在方法体中声明，局部变量运行阶段内存在栈中分配。

方法
方法调用的时候,在参数传递的时候,实际上传递的是变量中保存的那个"值"传过去了.

方法重载:

1、方法重载又被称为：overload

2、什么时候考虑使用方法重载？
功能相似的时候，尽可能让方法名相同

3、什么条件满足之后构成了方法重载？

• 在同一个类当中
• 方法名相同
• 参数列表相同：数量不同，顺序不同，类型不同

4、方法重载和什么有关系？

• 方法重载和参数名无关

方法的递归调用

1、什么是递归？
方法自身调用自身。
a(){
a();
}

2、递归必须有结束条件，否则会发生栈溢出错误。

例子：

//Created on 2021/2/17

public class Recursion01 {
    
    public static void main(String[] args) {
    
        int n=5;
        int retValue=sum(n);
        System.out.println("retValue="+retValue);
    }

    public static int sum(int n){
    
        if (n==1){
    
            return 1;
        }
        return n+sum(n-1);
    }
}

四、面向对象

面向过程和面向对象的区别

面向过程：主要关注点是：实现具体的过程，因果关系【集成显卡的开发思路】
优点：对于业务逻辑比较简单的程序，可以达到快速开发，前期投入成本较低。

缺点：难解决复杂的业务逻辑，耦合度非常高，其中一环出问题，整个系统受影响，没有独立体的概念，无法达到组件的复用。

面向对象：主要关注点是：主要关注对象独立体能完成哪些功能。【独立显卡开发思路】
优点：耦合度低，扩展力强。更容易解决现实世界当中更复杂的业务逻辑。

缺点：成本高，工作量大。

面向对象的三大特征

• 封装
• 继承
• 多态

面向对象开发软件，生命周期当中：

• 面向对象的分析：OOA
• 面向对象的设计：OOD
• 面向对象的编程：OOP

类和面向对象的概念

什么是类？
类在现实世界当中是不存在的，是一个模板，是一个概念，是人类大脑思考抽象的结果。

什么是对象？
对象是实际存在的个体。

重点：类描述的是对象的共同特征。

状态：一个类的属性
动作：一个类的方法

类的定义

语法结构
[修饰符列表] class 类名{

}

重点：属性通常是采用一个变量的方式来定义的

Java语言中所有的class都属于引用数据类型

类体=属性+方法

属性：存储数据采用变量的形式

由于变量定义在类体当中去，方法体之外，这种变量称为成员变量。

对象又被称为实例，new运算符在堆内存中开辟的空间称为对象。实例变量在堆内存中存储。

读取数据：引用.变量名；
修改数据：引用.变量名=值；

总结：JVM的内存管理

1、JVM（Java虚拟机）主要包括：栈内存、堆内存、方法区内存。

2、堆内存和方法区内存各有一个，一个线程一个栈内存。

3、方法调用的时候，该方法所需的内存空间在栈内存中分配，称为压栈，执行结束后，该空间释放，称为弹栈。

4、栈中主要存储的是方法中的局部变量。

5、方法的代码片段以及整个类的代码片段都被存储到方法区内存中，在类加载的时候这些代码会载入。

6、在程序执行过程中使用new运算符创建的Java对象，存储在堆内存中，对象内部有实例变量，所以实例变量存储在堆内存中。

7、变量分类：

• 局部变量【方法体中声明】
• 成员变量【方法体外声明】
• 实例变量【前边修饰符没有staic】
• 静态变量【前边修饰符有staic】

8、静态变量存储在方法区内存当中。

9、三块内存当中变化最频繁的是栈内存，最先有数据的是方法区内存，垃圾回收器主要针对堆内存。

10、垃圾回收器【自动垃圾回收机制，GC机制】什么时候会考虑某个Java对象的内存回收呢？

• 当内存当中的Java对象成为垃圾数据的时候，会被垃圾回收器回收。

什么时候堆内存中的Java对象会变成垃圾呢？

• 没有更多的引用指向它的时候
• 这个对象无法被访问，因为访问对象只能通过引用的方式访问。

空引用访问实例相关的数据一定会出现空指针异常。
实例相关的数据表示：这个数据访问的时候必须有对象的参与。

封装

1、复杂性封装，对外提供简单的操作入口

2、封装之后才会形成真正的对象，真正的独立体。

3、封装意味着以后的程序可以重复使用。并且这个事物应该适应性比较强，在任何场合都可以使用。

封装的步骤：
1、所有属性私有化，用private关键字修饰，表示修饰的所有数据只能在本类中访问。
2、对外提供简单的操作入口。

• 对外提供两个公开的方法，分别是set方法和get方法
• 修改属性，调用set方法
• 读取属性，调用get方法

3、set方法的命名规范：
public void setAge(){
age=a;
}

4、get方法的命名规范：
public int getAge(){
return age;
}

记住：

• setter和getter方法没有static关键字。
• 有static关键字修饰的方法怎么调用：类名.方法名（实参）；
• 没有static关键字修饰的方法怎么调用：引用.方法名（实参）；

Java中的构造方法：

1、构造方法又被称为构造函数/构造器/Constructor

2、构造方法语法
[修饰符列表] 构造方法名（形式参数列表）{
构造方法体；
}

3、回顾普通方法的语法结构：
[修饰符列表] 返回值类型 方法名（形式参数列表）{
方法体；
}

4、对于构造方法来说，“返回值类型”不需要指定，并且也不能
void，只要写上void就变成普通方法了。

5、对于构造方法来说，方法名必须和类名一致。

6、构造方法的作用？
构造方法存在的意义是，通过构造方法的调用，可以创建对象。

7、构造方法怎么调用？
普通方法是这样调用的：方法修饰符中有static的时候：类名.方法名（实参列表）、方法修饰符列表中没有static的时候，引用.方法名（实参列表）
new 构造方法名（实参列表）

8、构造方法执行后，有返回值吗？
每一个构造方法实际上执行结束之后都有返回值，但是这个“return 值；”语句不需要写。构造方法结束的时候，Java程序自动返回值。

9、注释：CTRL+/，多行注释，CTRL+shift+/

10、当一个类中没有定义构造方法的时候，，系统默认定义构造方法–缺省构造器

11、当一个类显示出构造方法，系统不再定义缺省构造器。

12、构造方法支持重载机制。

构造方法的作用：

• 1、创建对象
• 2、初始化实例变量的内容

this关键字

• 1、this是一个关键字，翻译为：这个
• 2、this是一个引用，是一个变量，变量保存了内存地址指向自身，this存储了JVM堆内存Java对象内部。
• 3、每一个对象都有一个this。
• 4、this可以出现在实例方法中，this指向当前正在执行这个动作的对象。
• 5、this在多数情况下可以省略不写。
• 6、this不能使用在带有static的方法当中。
• 7、用于区分实例变量和局部变量的时候this不能省略。
• 8、this（）只能出现在构造函数的第一行。

例子：

//Created on 2021/2/19
package javase;

public class ThisTest {
    
    public static void method1(){
    
        //调用doSome
        //完整方式调用
        ThisTest.doSome();
        //省略方式调用
        doSome();

        //调用doOther
        //完整方式调用
        ThisTest thisTest=new ThisTest();
        thisTest.doOther();
        //省略方式调用

        //访问i
        //完整方式访问
        System.out.println(thisTest.i);
        //省略方式访问
    }

    public void method2(){
    
        //调用doSome
        //完整方式调用
        ThisTest.doSome();
        //省略方式调用
        doSome();

        //调用doOther
        //完整方式调用
        this.doOther();
        //省略方式调用
        doOther();

        //访问i
        //完整方式调用
        System.out.println(this.i);
        //省略方式调用
        System.out.println(i);
    }

    //主方法
    public static void main(String[] args) {
    
        //要求在这里编写程序调用method1
        //使用完整方式调用
        ThisTest.method1();

        //使用省略方式调用
        method1();

        //要求在这里编写程序调用method2
        //使用完整方式调用
        ThisTest thisTest=new ThisTest();
        thisTest.method2();
        //使用省略方式调用
    }

    //没有static的变量
    int i = 10;

    //带有static的方法
    public static void doSome(){
    
        System.out.println("do some!");
    }

    //没有static的方法
    public void doOther(){
    
        System.out.println("do other!");
    }
}

static

什么时候成员变量声明为实例变量呢？
所有对象都有这个属性，但是这个属性的值会随着对象的变化而变化【不同对象的这个属性具体的值不同】

什么时候成员变量声明为静态变量呢？
所有的对象都有这个属性，并且所有对象的这个属性的值是一样的，建议定义为静态变量，节省内存的开销。

静态变量在类加载的时候初始化，内存在方法区中开辟。访问的时候不需要创建对象，直接使用“类名.静态变量”的方式访问。

总结：

• 1、static翻译为静态
• 2、static修饰的方法是静态方法
• 3、修饰的变量是静态变量
• 4、所有static修饰的元素都称为静态的，都可以使用类名.的方式访问，当然也可以使用引用.的方式访问
• 5、static修饰的所有元素都是类级别的特征。

可以使用static关键字来定义“静态代码块”

• 1、语法格式
  static{
  Java语句；
  }
• 2、静态代码块在类加载的时候执行，并且只执行一次。
• 3、静态代码块在一个类中可以编写多个，遵守从上至下的顺序执行。
• 4、静态代码块的作用是什么？
  例如日志记录。
  静态代码块是Java为程序员准备的一个特殊的时刻，这个特殊时刻被称为类加载时刻。若希望在此刻执行一段特殊的程序，这段程序可以直接放到静态代码块当中。
• 5、通常在静态代码块当中完成预备工作，先完成数据的准备工作，例如：初始化连接池，解析XML配置文件……

实例句块/代码块

• 1、实例代码块可以编写多个，遵循自上而下的顺序执行
• 2、实例代码块在构造方法执行之前执行，构造方法执行一次，实例代码块对应执行一次。
• 3、实例代码块也是Java语句为程序员准备的一个特殊时机，这个特殊时机被称为：对象初始化时机。

例子：

//Created on 2021/2/19
package static0;

public class Test {
    
    //构造函数
    public Test(){
    
        System.out.println("Test类的缺省构造器执行！");
    }

    //实例代码块
    {
    
        System.out.println(1);
    }

    //实例代码块
    {
    
        System.out.println(2);
    }

    //实例代码块
    {
    
        System.out.println(3);
    }

    //主方法
    public static void main(String[] args) {
    
        System.out.println("main begin!");
        new Test();
        new Test();
    }
}

运行结果：

方法什么时候定义为静态的？
方法描述的是动作，当所有的对象执行这个动作的时候，最终产生影响是一样的，那么这个动作已经不再属于某一个对象动作了，可以将这个动作提升为类级别的动作。

静态方法中无法直接访问实例变量和实例方法。

大多数方法都定义为实例方法，一般是一个行为或者一个动作在发生的时候，都需要对象参与。但是也有例外，例如：大多数“工具类”中的方法都是静态方法，因为工具类就是方便编程，为了方便方法的调用，自己不需要new对象是最好的。

继承

• 1、继承是面向对象三大特征之一。

• 2、继承的基本作用是代码的复用，但最重要的作用是有了继承才有“方法的覆盖”和“多态机制”

• 3、语法格式
  [修饰符列表] class 类名 extends 父类名{
  类体=属性+方法
  }

• 4、Java语言当中的继承只支持单继承，一个类不能同时继承很多类，只能继承一个类。在C++中支持多继承。

• 5、术语：
  B类继承A类，其中：
  A类称为：父类，基类，超类，superclass
  B类称为：子类，派生类，subclass

• 6、在Java语言当中子类继承父类都继承哪些数据呢？

• 私有的不支持继承

• 构造方法不支持继承

• 其他数据都可以被继承

• 7、虽然Java语言当中只支持单继承，但是一个类也可以间接继承其它类，例如：
  C extends B{
  }
  B extends A{
  }
  A extends T{
  }
  C直接继承B类，但是间接继承T和A

8、Java语言中假设一个类没有显示继承任何类，默认继承Java.lang.Object类。

方法的覆盖

• 1、又被称为方法的重写，英语单词：override/overwrite
• 2、什么时候要求使用方法重写？
  当父类中的方法已经无法满足当前子类的业务需求，子类有必要将父类中继承过来的方法进行重新编写，这个重新编写的过程称为方法重写/方法覆盖。
• 3、什么条件满足之后会发生方法的重写呢？
  方法重写发生在具有继承关系的父子类之间
  返回值类型相同，方法名相同，形参列表相同
  访问权限不能更低，可以更高。
  抛出异常不能更多，可以更少。
• 4、方法重写建议复制粘贴。
• 5、注意：
• 私有方法不能继承，所以不能覆盖
• 构造方法不能继承，不能覆盖
• 覆盖只针对方法，不谈属性
• 静态方法不存在覆盖

多态

• 1、Animal,Cat,Bird之间的关系：Cat继承与Animal,Bird继承Animal,Cat和Animal之间没有任何继承关系。
• 2、面向对象的三大特征：封装、继承、多态
• 3、几个概念：
• 向上转型：子类型–>父类型，即自动类型转换
• 向下转型：父类型–>子类型，即强制类型转换
• 无论向上转型还是向下转型，两种类型间必须要有继承关系

总结：
1、Java程序分为编译阶段和运行阶段。

2、先分析编译阶段，再分析运行阶段，编译无法通过，根本无法运行。

3、编译阶段编译器检查存在引用数据类型的方法而编译通过，这个过程称之为静态绑定，编译阶段绑定。只有静态绑定成功之后才有后续的运行。

4、在程序运行阶段，JVM堆内存当中真是创建的对象是Cat对象，那么程序在运行阶段一定会调用Cat对象的move（）方法，此时发生了程序的动态绑定，运行阶段绑定。

5、无论Cat类有没有重写move方法，运行阶段一定调用的是Cat对象的move方法，因为底层对象是就是Cat对象。

6、父类型引用指向子类型对象这种机制导致程序存在编译阶段绑定和运行阶段绑定两种不同的形态/状态，这种机制可以成为一种多态语法机制。

什么时候需要向下转型？
当调用的方法是子类型中特有的，在父类型当中不存在 .

多态在实际开发中的作用:
1、分析：主人喂养这个场景实现需要类的抽象
主人【类】
主人可以喂养宠物，所以主人有喂养这个动作。
宠物【类】
宠物可以吃东西，所以有吃东西这个动作。

2、面向对象编程的核心：定义好类，然后将类实例化为对象，每一个环境驱使一下，让各个对象之间协作起来形成一个系统。

3、多态的作用是什么？
降低程序的耦合度，提高程序的扩展力。
能使用多态尽量使用多态
父类型的引用指向子类型对象。

final关键字

1、final是一个关键字
2、final修饰的类无法被继承
3、final修饰的方法无法被覆盖
4、final修饰的变量一旦被赋值后，不可重新赋值
5、final修饰的实例变量，必须手动赋值，不能采用系统默认值
6、final修饰的引用，一旦指向某个对象之后，不能再指向其他对象，那么被指向的对象无法被垃圾器回收。但是对象的内存可以修改。

常量

final修饰的实例变量是不可变的，这种变量一般和static联合使用，被称为“常量”。

常量的定义格式：
public static final 类型 常量名=值；

Java规范中要求所有常量的名字全部大写，每个单词之间使用下划线连接。

Package和import

关于Java语言当中的包机制；
1、包又被称为package，为了方便程序员管理代码，查找方便，容易维护。

2、怎么定义package呢？
在Java源程序的第一行编写package语句。
package只能编写一个语句。

语法结构：
package 包名；

3、包名的命名规范：
公司域名倒序+项目名+模块名+功能名；
采用这种方式是为了避免重名。
例如：com.bjpowernode.oa.user.service;

4、包名要求全部小写，包名也是标识符，必须遵守命名规则。

5、一个包名将来对应一个目录。

6、使用了package机制之后，应该怎么编译运行？
使用了package机制之后，类名不再是javac Test,而是javac com.bjpowernode.oa.user.service.Test,即 编译：javac Java源文件路径

import语句用来完成导入其他类
不在同一个包下需要动手引入。

import需要编写在package语句之下，class语句之上。

import语法格式：
import 类名；
import 包名.*;

什么时候需要使用import?
不在Java.lang下或者不在同一个包路径之下的时候需要引入。

访问控制权限修饰符

1、访问控制权限修饰符来控制元素的访问范围

2、包括三类：

• public
• protected
• private

3、访问控制权限修饰符可以修饰类、变量、方法……

4、当某个数据只希望子类使用，使用protected进行修饰

5、修饰范围：
private<缺省<protected<public

类只能用public和缺省修饰【内部类除外】