Java面向对象学习笔记

面向对象的内存解析

默认初始化值的情况：（类的属性，根据其类型，都有默认的初始化值）

整型：（byte、short、int、long）：0

浮点型（float、double）：0.0

字符型（char）：0（或'\u0000'）

布尔型（boolean）：false

引用数据类型（类、数组、接口）：null

局部变量：没有默认初始化值

意味着，我们在调用局部变量之前，一定要显式赋值。特别的：形参在调用时，我们赋值即可

在内存中加载的位置：

属性：加载到堆空间中（非static）

局部变量：加载到栈空间

对象的内存解析

对象数组的内存解析

方法的参数传递_内存解析

引用数据类型的解构解析

类变量和实例变量的内存解析

对象数组题目

定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)，创建20个学生对象，学号为1到20，年级和成绩都由随机数确定，问题一：打印出3年级（state值为3）的学生信息， 问题二：使用冒泡排序按学生成绩排序，并跑遍历所有学生信息

提示：1)生成随机数：Math.random()，返回值类型double；

2)四舍五入取整：Math.round(double d)，返回值类型long

public class Test01_Student {
    private int number;//学号
    private int state;//年级
    private int score;//成绩

    public String info(){
        return "学号：" + number + "  成绩：" + score + "  年级：" + state;
    }

    //遍历学生信息
    public static void print(Test01_Student[] students){
        for(int i=0; i<students.length; i++){
            System.out.println(students[i].info());
        }
    }

    //查找某个年级的学生信息
    public static void searchState(Test01_Student[] students, int state){
        for(int i=0; i<students.length; i++){
            if(students[i].state == state){
                System.out.println(students[i].info());
            }
        }
    }

    //按照成绩排序
    public static void sort(Test01_Student[] students){
        for(int i=0; i<students.length-1; i++){
            for(int j=0; j<students.length-1-i; j++){
                if(students[j].score < students[j+1].score){
                    int temp = students[j].score;
                    students[j].score = students[j+1].score;
                    students[j+1].score = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        //声明Test01_Student类型的数组
        Test01_Student[] students = new Test01_Student[20];
        for(int i=0; i<students.length; i++){
            //给数组元素赋值
            students[i] = new Test01_Student();
            //给Test01_Student对象的属性赋值
            students[i].number = (i+1);//学号
            students[i].state = (int)(Math.random()*6+1);//年级：[1,6]
            students[i].score = (int)(Math.random()*101);//成绩：[0,100]
        }
        //遍历学生数组
        print(students);
        System.out.println("=======================");
        //打印3年级的学生信息
        searchState(students, 3);
        System.out.println("==========================");
        //冒泡排序学生成绩
        sort(students);
        print(students);
    }
}

四种访问权限修饰符

java权限修饰符public、protected、private置于类的成员定义前，用来限定对象对该类成员的访问权限

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	yes
(缺省)	yes	yes
protected	yes	yes	yes
public	yes	yes	yes	yes

对于class的权限修饰符只可以用public和default(缺省)

• public类可以在任意地方被访问

• default类只可以被同一个包内部的类访问

匿名对象的使用

我们创建的对象，没有显示的给赋一个变量名，即为匿名对象

特征：匿名对象只能调用一次

 //匿名对象
//        new Phone().sendEmail();
//        new Phone().playGame();

        new Phone().price = 1999;
        new Phone().showPrice();//0.0
        //*******************************
        PhoneMall mall = new PhoneMall();
//        mall.show(p1);
//        匿名对象的使用
        mall.show(new Phone());

JDK中主要的包介绍

1. java.lang：包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用的功能

2. java.net：包含执行于网络相关的操作的类和接口

3. java.io：包含能听过多种输入输出功能的类

4. java.util：包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数

5. java.text：包含了一些Java格式化相关的类

6. java.sql：包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面（GUI） B/S C/S

1、如果我们没有显示的声明一个类的父类的话，则此类继承于java.lang.Object类

2、所有的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类

3、意味着，所有java类具有java.lang.Object类声明的功能

方法的重写与重载

重载和重写的区别_要努力的嘻哈风范的博客-CSDN博客

方法的重写（override / overwrite）

1、重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作

2、应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的时子类重写父类的方法

3、重写的规定：

方法的声明：权限修饰符 返回值类型(形参列表) throws 异常的类型{

//方法体

}

约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法

1)子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同

2)子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符

>特殊情况：子类不能重写父类中声明为private权限的方法

3)返回值类型：

>父类被重写的方法的返回值类型是void，则子类重写的方法的返回值只能是void

>父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类

>父类被重写的方法的返回值类型是基本数据类型，则子类重写的方法的返回值类型必须是相同的基本数据类型

4)子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）

从编译和运行的角度来看

重载，是指有序存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数列表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。他们的调用地址在编译器就绑定了。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法

所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”

而对于多态，只有等到方法调用的那一刻，编译器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”

方法的形参

方法的形参的传递机制：值传递

1、形参：方法定义时，声明的小括号内的参数

实参：方法调用时，实际传递给形参的数据

2、值传递机制：

如果参数是基本数据类型，此时实参给形参的是实参真实存储的数据值

如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值

可变个数形参的方法、

具体使用：

1、可变个数形参的格式：

数据类型 ... 变量名

数据类型[] 变量名

2、当调用可变个数形参的方法时，传入的参数个数可以时：0个，1个，2个，...

3、可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载

4、可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载

5、可变个数形参在方法的形参中，最多只能声明一个可变形参

关于变量的赋值：

如果变量是基本数据类型，此时赋值的是变量所保存的数据值

如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值

public class Test04_MethodArgsTest {

    public static void main(String[] args) {
        Test04_MethodArgsTest test = new Test04_MethodArgsTest();
        test.show(2);
        test.show(new String[]{"DD", "EE"});
        test.show(new String[]{"AA","BB","CC"});

    }
    public void show(int i){
        System.out.println(i);
    }
    public void show(String s){
        System.out.println("show(String)");
    }
//    public void show(String ... strs){
//        System.out.println("show(String ... strs)");
//    }

    public void show(String[] strs){
        System.out.println("show(String ... strs)");

        for(int i=0; i<strs.length; i++){
            System.out.println(strs[i]);
        }
    }
    public void show(int i, String[] strs){
        System.out.println("2222");
    }
}

递归

递归方法的使用（了解）

1、递归方法：一个方法体内调用它自身

2、方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无需循环控制

递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环

class RecursionTest{

    //例1：计算1-n之间所有自然数的和
    public int getSum(int n){
        if(n==1){
            return 1;
        }else {
            return n + getSum(n-1);
        }
    }

    //例2：计算1-n之间所有自然数的乘积：n!
    public int getSum1(int n){
        if(n==0){
            return 1;
        }else {
            return n * getSum1(n-1);
        }
    }

    //例3：已知有一个数列：f(0) = 1,f(1) = 4,f(n+2) = 2*f(n+1) + f(n),
    //其中n是大于0的整数，求f(10)的值
    public int f(int n){
        if(n == 0){
            return 1;
        }else if(n == 1){
            return 4;
        }else{
//            return f(n + 2) - 2 * f(n + 1);
            return 2*f(n-1) + f(n-2);
        }
    }

    //例4：斐波那契数列

    //例5：汉诺塔问题

    //例6：快排

}

this调用构造器

1、我们在类的构造器中，可以显式的使用“this(形参列表)”方式，调用本类中指定的其他构造器

2、构造器中不能通过“this(参数列表)”方式调用自己

3、如果一个类中有n个构造器，则最多有n-1个构造器中使用了“this(形参列表)”

4、规定：“this(形参列表)”必须声明在当前构造器的首行

5、构造器内部，最多只能声明一个“this(形参列表)”，来调用其他构造器

public Test10_Account(){

System.out.println("111");

}

public Test10_Account(int id){

this();

this.id = id;

}

public Test10_Account(int id, double balance){

this(id);

this.balance = balance;

}

package关键字的使用

1、为了更好的实现项目中类的管理，提供包的概念

2、使用package声明类或接口所属的包，声明在源文件的首行

3、包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”

4、每“.”一次，就代表一层文件目录

补充：同一个包下，不能命名同名的接口、类

不同的包下，可以命名同名的接口 、类

import关键字的使用

import：导入

1、在源文件中显式的使用import结构导入指定包下的类、接口

2、声明在包的声明和类的声明之间、

3、如果需要导入多个结构，则并列写出即可

4、可以使用“xxx.*”的方式，表示可以导入xxx包下的所有结构

5、如果使用类或接口式java.lang包下定义的，则可以省略import结构

6、如果使用的类或接口是本包下定义的，则可以省略import结构

7、如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示

8、使用“xxx.*”方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需显示导入

9、import static:导入指定类或接口中的静态结构。

super关键字的使用

1、super理解为：父类的

2、super可以用来调用：属性、方法、构造器

3、super的使用：调用属性和方法

1)我们可以在子类的方法或构造器中。勇敢“super.属性”或“super.方法”的方式，

显示的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略“super.”

2)特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用

“super.属性”的方式，表明调用的是父类中声明的属性

3)特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则

必须显式的使用“super.方法”的方式，表明调用的时父类中被重写的方法

4、super调用构造器

1)我们可以在子类的构造器中显示的使用“super(形参列表)”的方式，调用父类中声明的指定的构造器

2)“super(形参构造器)”的使用，必须声明在子类构造器的首行

3)我们在类的构造器中，针对“this(形参列表)”或“super(形参列表)”只能二选一，不能同时出现

4)在构造器的首行，没有显示的声明“this(形参列表)”或“super(形参列表)”，则默认调用的时父类中空参的构造器

5)在类的多个构造器中，至少有一个类的构造器中使用了“super(形参列表)”，调用父类中的构造

子类对象实例化的全过程

1、从结果上来看：（继承性）

子类继承父类以后，就获取了父类中声明的属性或方法

创建子类对象，在堆空间中，就会加载所有父类中声明的属性

2、从过程上来看

当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用父类的构造器，进而调用父类的构造器

直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有父类中的结构

子类对象才可以考虑进行调用

明确：虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象

面向对象特征之三：多态性

1、理解多态性：可以理解为一个事物的多种形态

2、何为多态性

对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）

3、多态的使用：虚拟方法调用

有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的时子类重写父类的方法

总结：编译看左边，运行看右边

java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量

的对象决定，简称：编译时，看左边；运行时，看右边。

编译时类型和运行时类型不一致，就出现了对象的多态性

多态情况下，“看左边”：看的是父类的引用（父类中不具备子类特有的方法）

“看右边”：看的是子类的对象（实际运行的时子类重写父类的方法）

4、多态性的使用前提：1)类的继承关系 2)方法的重写

5、对象的多态性只适用于方法，不适用于属性（编译和运行都看左边）

//多态性的使用举例一
public class Test29_AnimalTest {
    public static void main(String[] args) {
        Test29_AnimalTest test = new Test29_AnimalTest();
        test.func(new Dog());

        test.func(new Cat());
    }

    public void func(Animal animal){ //Animal animal = new Dog/Cat();
        animal.eat();
        animal.shout();
        if(animal instanceof Dog){
            Dog d = (Dog) animal;
            d.watchDoor();
        }
    }

//    public void func(Dog dog){
//        dog.eat();
//        dog.shout();
//    }
//    public void func(Cat cat){
//        cat.eat();
//        cat.shout();
//    }


}

class Animal{
    public void eat(){
        System.out.println("动物：进食");
    }
    public void shout(){
        System.out.println("动物：叫");
    }
}

class Dog extends Animal{
    public void eat(){
        System.out.println("狗吃骨头");
    }
    public void shout(){
        System.out.println("汪汪汪");
    }
    public void watchDoor(){
        System.out.println("看门");
    }

}
class Cat extends Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void shout(){
        System.out.println("喵喵喵");
    }
}

//举例二
class Order{
    public void method(Object obj){

    }
}

//举例三
class Driver{
    public void doData(Connection conn){ //conn = new MySQLConnection/OracleConnection();
        //规范的步骤去操作数据
//        conn.method1();
//        conn.method2();
//        conn.method3();

    }
}

instanceof关键字的使用&向下转型的几个常见问题

public class Test30_Instanceof {

    /*
    * Person p2 = new Man();
    * //不能调用子类所特有的方法、属性：编译时，p2时Person类型
    * p2.name="Tom";
    * p2.earnMoney();
    * p2.isSmoking = true;
    * //有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于白能量声明为父类类型，导致
    * 编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用
    *
    * 如何才能调用子类特有的属性和方法？
    * 向下转型：使用强制类型转换符
    * Man m1 = (Man)p2;
    * m1.earnMoney();
    * m1.isSmoking = true;
    *
    * 使用强制时，可能出现ClassCastException的异常
    * Woman w1 = (Woman)p2;
    * w1.goShopping();
    *
    *
    * instanceof关键字的使用
    *
    * a instanceof A：判断对象a是否是类A的实例。如果是，返回true，如果不是返回false
    *
    * 使用情境：为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先
    *   进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型
    *
    * 如果a instanceof A返回true，则a instanceof B也返回true 其中类B是类A的父类
    *
    * if(p2 instanceof Woman){
    *       Woman w1 = (Woman)p2;
    *       w1.goShopping();
    *       sout(Woman);
    * }
    *
    * if(p2 instanceof Man){
    *       Man w2 = (Man)p2;
    *       w2.earnMoney();
    *       sout(Man);
    * }
    *
    * if(p2 instanceof Person){
    *       sout(Person);
    * }
    *
    * if(p2 instanceof Object){
    *       sout(Object);
    * }
    *
    * 向下转型的几个常见问题
    * 练习：
    * 问题一：编译时通过，运行时不通过
    * 举例一：
    * Person p3 = new Woman();
    * Man m3 = (Man)p3;
    * 举例二：
    * Person p4 = new Person();
    * Man m4 = (Man)p4;
    *
    * //问题二：编译通过，运行时也通过
    * Object obj = new Woman();
    * Person p = (Person)obj;
    *
    * //问题三：编译不通过
    * Man m5 = new Woman();
    *
    * String str = new Date();
    *
    * Object o = new Date();
    * String str1 = (String)o;
    *
    *
    *
    */
}

1、若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法

系统将不可能把父类里的方法转移到子类中：编译看左边，运行看右边

2、对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，

这个实例变量依然不可能覆盖父类中定义的实例变量：编译运行都看左边

class Base{
    int count = 10;
    public void display(){
        System.out.println(this.count);
    }
}

class Sub extends Base{
    int count = 20;
    public void display(){
        System.out.println(this.count);
    }

}

public class Test31_FieldMethodTest{
    public static void main(String[] args) {
        Sub s = new Sub();
        System.out.println(s.count);//20
        s.display();//20

        Base b = s;//多态性
        //==：对于引用数据类型来讲，比较的是两个引用数据类型变量的地址值是否相同
        System.out.println(b == s);//true
        System.out.println(b.count);//10
        b.display();//20
    }

}

考察多态的题目

继承成员变量和继承方法的区别

public class Test34_InterviewTest {

    public static void main(String[] args) {
        Base1 base = new Sub1();
        base.add(1, 2, 3);
//
//        Sub1 s = (Sub1)base;
//        s.add(1,2,3);
    }
}

class Base1 {
    public void add(int a, int... arr){
        System.out.println("base");
    }
}

class Sub1 extends Base1{
    public void add(int a, int[] arr){
        System.out.println("sub_1");
    }
//    public void add(int a, int b, int c){
//        System.out.println("sub_2");
//    }
}

static关键字的使用

1.static：静态的

2.static可以用来修饰：属性、方法、代码块、内部类、

3.使用static修饰属性：静态变量（或类变量）

3.1属性，按是否使用static修饰，又分为：静态属性 VS 非静态属性（实例变量）

实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的

非静态属性时，不会导致其他对象中同样的属性值的修改

静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象

调用此此静态变量时，是修改过了的

3.2 static修饰属性的其他说明：

① 静态变量随着类的加载而加载。可以通过“类.静态变量”的方式进行调用

② 静态变量的加载要早于对象的创建

③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中

④ 类变量 实例变量

类 yes no

对象 yes yes

3.3静态属性举例：System.out; Math.PI;

4.使用static修饰方法：静态方法

① 随着类的加载而加载，可以通过“类.静态方法”的方式进行调用

② 静态方法 非静态方法

类 yes no

对象 yes yes

③ 静态方法中，只能调用静态的方法或属性

非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

5.static注意点：

5.1 在静态的方法内，不能使用this关键字、super关键字

5.2 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解

6.开发中，如何确定一个属性是否要声明为static的？

> 属性是可以被多个对象所共享的，不会随着对象的不同而不同的

开发中，如何确定一个方法是否要声明为static的？

> 操作静态属性的方法，通常设置为static的

> 工具类中的方法，习惯上声明为static的，比如Math、Arrays、Collections

成员变量（全局变量）和局部变量都有生命周期

局部变量除形参外，需显示初始化

public class Test01_StaticTest {
    public static void main(String[] args) {


        Chinese.nation = "中国";

        Chinese c1 = new Chinese();
        c1.name = "姚明";
        c1.age = 40;
        c1.nation = "CHN";

        Chinese c2 = new Chinese();
        c2.name = "马龙";
        c2.age = 30;
        c2.nation="CHINA";

        System.out.println(c1.nation);

        //编译不通过
//        Chinese.name="11";
        c1.eat();

        Chinese.show();
        //编译不通过
//        Chinese.eat;


    }
}

//中国人
class Chinese{
    String name;
    int age;
    static String nation;

    public void eat(){
        System.out.println("中国人吃中餐");
        //调用非静态结构
        this.info();
        System.out.println("name: "+name);
        //调用静态结构
        walk();
        System.out.println("nation: " + Chinese.nation);
    }

    public static void show(){
        System.out.println("我是一个中国人！");
        //不能调用非静态的结构
//        eat();
//        name = "Tome";
        //可以调用静态的结构
        System.out.println(Chinese.nation);
        walk();
    }
    public void info(){
        System.out.println("name: "+name+",age:"+age);
    }
    public static void walk(){

    }

}

main()方法的使用说明

1.main()方法作为程序的入口

2.main()方法也是普通的静态方法

3.main()方法可以作为我们与控制台交互的方式。（之前：使用Scanner）

public class Test07_MainTest {
    public static void main(String[] args) { //入口

        Main.main(new String[100]);

    }
}

class Main{
    public static void main(String[] args) {

        for(int i=0; i<args.length; i++){
            args[i] = "args_" + i;
            System.out.println(args[i]);
        }
    }
}

代码块（或初始化块）

1.代码块的作用：用来初始化类、对象

2.代码块如果有修饰的话，只能使用static

3.分类：静态代码块 vs 非静态代码块

4.静态代码块

>内部可以有输出语句

>随着类的加载而执行，而且只执行一次

>如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行

>静态代码块要优先于非静态代码块执行

>静态代码块内只能调用静态的属性、静态的方法、不能调用非静态的结构

5.非静态代码块

>内部可以有输出语句

>随着对象的创建而执行

>每创建一个对象，就执行一次非静态代码块

>作用：可以创建对象时，对对象的属性等进行初始化

>如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行

>非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法

对属性可以赋值的位置：

①默认初始化

②显示初始化

③构造器初始化

④有了对象以后，可以通过”对象.属性“或”对象.方法“的方式进行赋值

⑤在代码块中赋值

执行的先后顺序：① - ② / ⑤ - ③ - ④

总结：由父及子，静态先行

public class Test09_BlockTest {
    public static void main(String[] args) {

        String desc = Person.desc;
        System.out.println(desc);

        Person p1 = new Person();
        Person p2 = new Person();
        System.out.println(p1.age);

        Person.info();
    }
}

class Person{
    //属性
    String name;
    int age;
    static String desc = "我是一个人";

    //构造器
    public Person(){

    }
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }

    //非static代码块
    {
        System.out.println("hello, block-1");
        //调用非静态结构
        age = 1;
        eat();
        //调用静态结构
        desc = "我是一个爱学习的人";
        info();

    }
    {
        System.out.println("hello, block-2");
    }
    //static代码块
    static{
        System.out.println("hello, static block-1");
        //只能调用静态结构
        desc = "我是一个爱学习的人";
        info();
//        eat();
    }
    static{
        System.out.println("hello, static block-2");
    }


    //方法
    public void eat(){
        System.out.println("吃饭");
    }
    @Override
    public String toString(){
        return "Person [name=" + name + ", age=" + age + "]";
    }

    public static void info(){
        System.out.println("我是一个快乐的人！");
    }
}

final：最终的

1.final可以用来修饰的结构：类、方法、变量

2.final用来修饰一个类：此类不能被其他类所继承

比如：String类、System类、StringBuffer类

3.final用来修饰方法：表明此方法不可以被重写

比如：Object中的getClass()

4.final修饰变量：此时的“变量”就称为一个常量

4.1 final修饰属性：可以考虑赋值的位置有：显示初始化、代码块中初始化、构造器中初始化

4.2 final修饰局部变量：

尤其是使用final修饰形参是，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值

以后，就只能在方法内使用此形参，但不能进行重新赋值了。

static final 用来修饰常量：全局常量

public class Test10_FinalTest {
    final int WIDTH = 0;
    final int LEFT;
    final int RIGHT;
//    final int DOWN;
    {
        LEFT = 1;
    }
    public Test10_FinalTest(){
        RIGHT = 2;
    }
    public Test10_FinalTest(int n){
        RIGHT = n;
    }
    public void doWidth(){
//        WIDTH = 20;
    }
//    public void setDown(int down){
//        this.DOWN = down;
//    }
    public void show(){
        final int NUM = 10;//常量
//        NUM += 20;
    }
    public void show(final int num){
//        num = 20;//编译不通过
        System.out.println(num);
    }
    public static void main(String[] args) {
        int num = 10;
        num = num + 5;

        Test10_FinalTest test = new Test10_FinalTest();
//        test.setDown(3);
        test.show(10);
    }

}
final class FinalA{

}
//class B extends FinalA{
//
//}
//class C extends String{
//
//}

排错

public class Test11_FinalInterview01 {
    public int addOne(final int x){
//        return ++x;
         return x +1;
    }
}

public class Test12_FinalInterview02 {
    public static void main(String[] args) {
        Other o = new Other();
        new Test12_FinalInterview02().addOne(o);
    }
    public void addOne(final Other o){
//        o = new Other();
        o.i++;
    }
}

class Other{
    public int i;
}

内部类

1.Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类

2.内部类的分类：成员内部类(静态 非静态) VS 局部内部类（方法内、代码块内、构造器内）

3.成员内部类

一方面，作为外部类的成员：

>调用外部类的结构

>可以被static修饰

>可以被4种不同的权限修饰

另一方面作为一个类：

>类内部可以定义属性、方法、构造器等

>可以被final修饰，表示此类不能被继承。言外之意，不使用final，可以就可以被继承

>可以被abstract修饰

4.关注如下的3个问题

4.1如何实例化成员内部类的对象

4.2如花在成员内部类中区分调用外部类的结构

4.3开发中局部内部类的使用

public class Test13_InnerClass {
    public static void main(String[] args) {
        //创建Dog实例（静态的成员内部类）
        Person1.Dog dog = new Person1.Dog();
        dog.show();
        //创建Cat实例（非静态的成员内部类）：
//        Person1.Cat cat = new Person1.Cat();//错误
        Person1 p = new Person1();
        Person1.Cat cat = p.new Cat();
        cat.sing();
        System.out.println();
        cat.display("黄");
    }
}

class Person1{

    String name = "小明";
    int age;
    public void eat(){
        System.out.println("chichichi");
    }

    //静态成员内部类
    static class Dog{
        String name = "dog";
        public Dog(){

        }
        public void show(){
            System.out.println("wangwang");
//            eat();
        }

    }
    //非静态成员内部类
//    final class Cat{
     class Cat{
        String name = "cat";
        public Cat(){

        }
        public void sing(){
            System.out.println("miaomiao ");
//            eat();
            Person1.this.eat();//调用外部类的非静态属性
        }

        public void display(String name){
            System.out.println(name);//方法的形参
            System.out.println(this.name);//内部类的属性
            System.out.println(Person1.this.name );//外部类的属性
        }
    }



    public void method(){
        //局部内部类
        class AA{

        }
    }
    {
        //局部内部类
        class BB{

        }
    }
    public Person1(){
        //局部内部类
        class CC{

        }
    }
}

abstract关键字的使用

1.abstract:抽象的

2.abstract可以用来修饰的结构：类、方法

3.abstract修饰类：抽象类

> 抽象类不能实例化

> 抽象类一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）

> 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作

4.abstract修饰方法：抽象方法

> 抽象方法只有方法的声明，没有方法体

> 包含抽象方法的类一定是一个抽象类。反之，抽象类中可以没有抽象方法的

> 若子类重写了父类中的所以的抽象方法后，此子类可以实例化

若子类没有重写父类中的所以抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

abstract使用上的注意点：

1.abstract不能用来修饰：属性、构造器等结构

2.abstract不能用来修饰私有方法、静态方法、final的方法、final的类

//抽象类的应用：模板方法的设计模式
public class Test07_TemplateTest {
    public static void main(String[] args) {
        SubTemplate subTemplate = new SubTemplate();
        subTemplate.spendTime();
    }
}

abstract class Template{
    //计算某段代码执行花费的时间
    public void spendTime(){
        long start = System.currentTimeMillis();
        this.code();//异变部分、不确定部分
        long end = System.currentTimeMillis();
        System.out.println("花费的时间：" + (end - start));
    }

    public abstract void code();
}

class SubTemplate extends Template{

    @Override
    public void code() {
        for(int i=2; i<=1000; i++){
            boolean isFlag = true;
            for(int j=2; j<=Math.sqrt(i); j++){
                if(i % j == 0){
                    isFlag =  false;
                    break;
                }
            }
            if(isFlag){
                System.out.println(i);
            }
        }
    }
}

匿名子类的匿名对象

public class Test06_EmployeeTest {
    public static void main(String[] args) {
        //多态
        Test03_Employee manager = new Test04_Manager("库克", 1001, 5000, 50000);


        //创建了一个匿名子类的对象：manager1
        Test03_Employee manager1 = new Test03_Employee() {
            @Override
            public void work() {
                System.out.println("11");
            }
        };

        //创建匿名子类的匿名对象
        method(new Test03_Employee() {
            @Override
            public void work() {

            }
        });

        manager.work();
        Test05_CommonEmployee commonEmployee = new Test05_CommonEmployee();
        commonEmployee.work();
    }

    public static void method(Test03_Employee employee){
        System.out.println("222");
    }
}

interface接口

1.接口使用interface来定义

2.Java中，接口和类是并列的两个结构

3.如何定义接口：定义接口中的成员

3.1 JDK7及以前：只能定义全局常量和抽象方法

> 全局常量：public static final的，但是书写时可以省略不写

> 抽象方法：public abstract

3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法（略）

4.接口中不能定义构造器，意味着接口不能实例化

5.Java开发中，接口通过让类去实现（implements）的方式来使用

如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化

如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类

6.Java类可以实现多个接口 --> 弥补了Java单继承的局限性

格式：class AA extends BB implements CC,DD,EE

7.接口与接口之间可以继承，而且可以多继承

8.接口的具体使用，体现多态性

9.接口，实际上可以看做是一种规范

面试题：抽象类与接口有什么异同？

 /* 接口的使用
 * 1.接口使用上也满足多态性
 * 2.接口实际上就是定义了一种规范
 * 3.在开发中，体会面向接口编程*/
public class Test09_USBTest {
    public static void main(String[] args) {
        Computer computer = new Computer();
        //1.创建了接口的非匿名实现类的非匿名对象
        Flash flash = new Flash();
        computer.transferData(flash);

        //2.创建了接口的非匿名实现类的匿名对象
        computer.transferData(new Printer());

        //3.创建了接口的匿名实现类的非匿名对象
        USB phone = new USB() {
            @Override
            public void start() {
                System.out.println("手机开始工作");
            }

            @Override
            public void stop() {
                System.out.println("手机结束工作");
            }
        };
        computer.transferData(phone);

        //4.创建了接口的匿名实现类的匿名对象
        computer.transferData(new USB() {
            @Override
            public void start() {
                System.out.println("mp3开始工作");
            }

            @Override
            public void stop() {
                System.out.println("mp3结束工作");
            }
        });
    }
}

class Computer{
    public void transferData(USB usb){ //USB usb = new Flash()
        usb.start();
        System.out.println("具体传输数据的细节");
        usb.stop();
    }
}

interface USB{
    //常量：定义了长、宽、最大最小的传输速度等

    void start();

    void stop();

}

class Flash implements USB{

    @Override
    public void start() {
        System.out.println("U盘开始工作");
    }

    @Override
    public void stop() {
        System.out.println("U盘结束工作");
    }
}

class Printer implements USB{
    @Override
    public void start() {
        System.out.println("打印机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("打印机结束工作");
    }
}

接口的应用：代理模式

public class Test10_NetWorkTest {
    public static void main(String[] args) {
        Server server = new Server();
//        server.browse();
        ProxyServer proxyServer = new ProxyServer(server);
        proxyServer.browse();
    }
}

interface NetWork{
    public void browse();
}

//被代理类
class Server implements NetWork{

    @Override
    public void browse() {
        System.out.println("真实的服务器访问网络");
    }
}

//代理类
class ProxyServer implements NetWork{

    private NetWork netWork;

    public ProxyServer(NetWork netWork){
        this.netWork = netWork;
    }

    public void check(){
        System.out.println("联网之前的检查工作");
    }

    @Override
    public void browse() {
        check();
        netWork.browse();
    }
}

面试题：

public class Test11_Interview01 {
}

interface A{
    int x = 0;
}
class B{
    int x = 1;
}
class C extends B implements A{
    public void pX(){
//        System.out.println(x);//编译不通过，x不明确
        System.out.println(super.x);//1
        System.out.println(A.x);//0
    }

    public static void main(String[] args) {
        new C().pX();
    }
}

public class Test12_Interview02 {
}
interface  Playable{
    void play();
}
interface  Bounceable{
    void play();
}
interface Rollable extends Playable,Bounceable{
    Ball ball = new Ball("PingPang");
}
class Ball implements Rollable{
    private String name;
    public String getName(){
        return name;
    }
    public Ball(String name){
        this.name = name;
    }

    @Override
    public void play() {
//        ball = new Ball("Football");
//        final 属性不能重新赋值
//        System.out.println(ball.getName);
    }
}

interface Test13_CompareObject {

    //若返回值是0，代表相等；若为正数，代表前对象大；负数代表前对象小
    public int compareTo(Object o);
}
public class Test14_Circle {
    private Double redius;

    public Test14_Circle(){

    }
    public Test14_Circle(Double redius) {
        this.redius = redius;
    }

    public Double getRedius() {
        return redius;
    }

    public void setRedius(Double redius) {
        this.redius = redius;
    }
}
public class Test15_ComparableCircle extends Test14_Circle implements Test13_CompareObject{

    public Test15_ComparableCircle(double redius) {
        super(redius);
    }

    @Override
    public int compareTo(Object o) {
        //若返回值是0，代表相等；若为正数，代表前对象大；负数代表前对象小
        if(this == o){
            return 0;
        }
        if(o instanceof Test15_ComparableCircle){
            Test15_ComparableCircle c = (Test15_ComparableCircle) o;
            //错误
//            return (int) (this.getRedius() - c.getRedius());

            //方式一
//            if(this.getRedius() > c.getRedius()){
//                return 1;
//            }else if(this.getRedius() < c.getRedius()){
//                return -1;
//            }else {
//                return 0;
//            }

            //方式二
            //当属性radius声明为Double类型时，可以调用包装类的方法
            return this.getRedius().compareTo(c.getRedius());
        }else {
            return 0;
//            throw new RuntimeException("传入的数据类型不匹配")；
        }

    }
}
public class Test16_InterfaceTest {
    public static void main(String[] args) {
        Test15_ComparableCircle comparableCircle1 = new Test15_ComparableCircle(3.4);
        Test15_ComparableCircle comparableCircle2 = new Test15_ComparableCircle(3.6);
        int compareValue = comparableCircle1.compareTo(comparableCircle2);
        if(compareValue > 0){
            System.out.println("c1对象大");
        }else if(compareValue < 0){
            System.out.println("c2对象大");
        }else{
            System.out.println("一样大");
        }
        System.out.println(compareValue);

        int compareValue1 = comparableCircle1.compareTo(new String("AA"));
        System.out.println(compareValue1);
    }
}

单例设计模式

1.所谓类的单例设计模式，就是采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例

2.如何实现?

饿汉式 & 懒汉式

3.区分饿汉式和懒汉式

饿汉式：

坏处：对象加载时间过长

好处：饿汉式是线程安全的

懒汉式：

好处：延迟对象的创建、

目前的写法坏处：线程不安全 到多线程内容时再修改

单例设计模式的优点：

由于单例设计模式只生成一个实例，减少了系统性能开销，当对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，

则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决

单例（Singleton）设计模式的应用场景

1. 网站的计数器，一般也是单例模式实现，否则难以同步

2. 应用程序的日志应用，一般都使用单例模式实现，这一般是由共享的日志文件一直处于打开状态，因为只有一个实例去操作，否则内容不好追加

3. 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源

4. 项目中，读取配置文件的类，一般也只有一个对象，没有必要每次使用配置文件数据，都生成一个对象去读取

5. Application也是单例模式的典型应用

6. Windows的Task Manager（任务管理器）就是很典型的单例模式

7. Windows的Recycle Bin（回收站）也是典型的单例模式应用。在整个系统运行过程中回收站一直维护着仅有的一个实例

public class Test05_SingletonTest1 {
    public static void main(String[] args) {
//        Bank b1 = new Bank();
        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();
    }
}

//饿汉式
class Bank{

    //1.私有化类的构造器
    private Bank(){

    }

    //2.内部创建类的对象
    private static Bank instance = new Bank();

    //3.提供公共的静态的方法，返回类的对象
    public static Bank getInstance(){
        return instance;
    }
}

//单例模式的懒汉式实现
public class Test06_SingletonTest2 {
    public static void main(String[] args) {
        Order order1 = Order.getInstance();
        Order order2 = Order.getInstance();
        System.out.println(order1 == order2);//true
    }


}

class Order{

    //1.私有化类的构造器
    private Order(){

    }

    //2.声明当前类对象，没有初始化
    //4.此对象也必须声明为static
    private static Order instance = null;

    //3.声明public、static的返回当前类对象的方法
    public static Order getInstance(){
        if(instance == null)
            instance = new Order();
        return instance;
    }
}