Java基础篇：接口 + 多态 + 四种权限修饰符

java基础篇

IDEA常用快捷键

快捷键	功能
Alt+Enter	自动修正代码
Ctrl+Y	删除光标所在行
Ctrl+D	复制光标所在行的内容，插入光标位置下面
Ctrl+Alt +L	格式化代码
Ctrl+/	单行注释，再按取消注释
Ctrl+Shift+/	选中代码注释，多行注释，再按取消注释。
Alt+Ins	自动生成代码，toString，get，set等方法
Alt+Shift+上下箭头	移动当前代码行

接口的定义

接口的定义基本格式

package Demo33;
/*
* 接口就是多个类的公共规范。
* 接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。
*
* 如何定义一个接口的格式：
* public interface 接口名称 {
*       // 接口内容
* }
*
* 备注：换成了关键字 interface 之后，编译生成的字节码文件仍然是：.java --> .class
*
* 如果是 Java 7,那么接口中可以包含的内容有：
* 1.常量
* 2.抽象方法
*
* 如果是Java 8,还可以额外包含有：
* 3.默认方法
* 4.静态方法
*
* 如果是Java 9,还可以额外包含有：
* 5.私有方法
* 
* */
public class Interface {
}

接口的抽象方法定义和使用

package Demo33;
/*
* 在任何版本的java中，接口都能定义抽象方法：
* 格式：public abstract 返回值类型 方法名称(参数列表);
* 
* 注意事项：
* 1.接口当中的抽象方法：修饰符必须是两个固定的关键字：public abstract
* 2.这两个关键字修饰符，可以选择性地省略。（今天刚学，所以不推荐）
* 3.方法的三要素，可以随意定义。
* */
public interface MyInterfaceAbstract {
    // 这是一个抽象方法
    public abstract void methodAbs1();

    // 这也是抽象方法
    abstract void methodAbs2();
    
    // 这是一个抽象方法
    public void methodAbs3();

    // 这也是抽象方法
    void methodAbs4();
}

• 使用

package Demo33;
/*
* 接口就是多个类的公共规范。
* 接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。
*
* 如何定义一个接口的格式：
* public interface 接口名称 {
*       // 接口内容
* }
*
* 备注：换成了关键字 interface 之后，编译生成的字节码文件仍然是：.java --> .class
*
* 如果是 Java 7,那么接口中可以包含的内容有：
* 1.常量
* 2.抽象方法
*
* 如果是Java 8,还可以额外包含有：
* 3.默认方法
* 4.静态方法
*
* 如果是Java 9,还可以额外包含有：
* 5.私有方法
*
* 接口使用步骤：
* 1.接口不能直接使用，必须有一个"实现类" 来 "实现" 该接口。
*   格式：
*   public class 实现类名称 implements 接口名称 {
*       // ...
*   }
* 2.接口的实现类必须覆盖重写（【实现】）接口中所有的抽象方法。
*   【实现】：去掉abstract关键字，加上方法体大括号。
* 3.创建实现类的对象，进行使用。
*
* 注意事项：
* 如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。
* */
public class Interface {

    public static void main(String[] args) {
        // 错误写法：不能直接new接口对象使用。
        // MyInterfaceAbstract inter = new MyInterfaceAbstract();

        // 创建实现类的对象使用：
        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        impl.methodAbs1();
        impl.methodAbs2();
    }

}

接口的默认方法定义和使用

package Demo33;
/*
  接口的默认方法：
   * 解决接口升级的问题
   * 拼接函数模型
   
* 1.接口的默认方法：可以通过接口实现类对象，直接调用。
* 2.接口的默认方法，也可以被接口实现类进行覆盖重写。
* */
public class Demo02Interface {
    public static void main(String[] args) {
        // 创建了实现类对象
        MyInterfaceDefaultA a = new MyInterfaceDefaultA();
        a.methodAbs(); // 调用抽象方法，实际运行的是右侧实现类。

        // 调用默认方法：如果实现类当中没有，会向上找接口
        a.methodDefault(); // 这是新添加的默认方法
        System.out.println("========");

        MyInterfaceDefaultB b = new MyInterfaceDefaultB();
        b.methodAbs();
        b.methodDefault(); // 实现类B覆盖重写了接口的默认方法
    }
}

• 抽象方法

package Demo33;
/*
* 从Java 8开始，接口里允许定义默认方法。
* 格式：
* public default 返回值类型 方法名称(参数列表) {方法体}
*
* 备注：接口当中的默认方法，可以解决接口升级的问题。
* */
public interface MyInterfaceDefault {

    // 抽象方法
    public abstract void methodAbs();

    // 新添加了一个抽象方法,原来的方法会受影响。解决方法：改成默认方法
    // public abstract void methodAbs2();

    // 新添加的方法，改为默认方法
    public default void methodDefault() {
        System.out.println("这是新添加的默认方法");
    }
}

• 抽象方法A

package Demo33;

public class MyInterfaceDefaultA implements MyInterfaceDefault{

    @Override
    public void methodAbs() {
        System.out.println("实现了抽象方法，AAA");
    }
}

• 抽象方法B

package Demo33;

public class MyInterfaceDefaultB implements MyInterfaceDefault{

    @Override
    public void methodAbs() {
        System.out.println("实现了抽象方法，BBB");
    }

    @Override
    public void methodDefault() {
        System.out.println("实现类B覆盖重写了接口的默认方法");
    }

}

接口的静态方法定义和使用

package Static.MyInter;
/*
* 注意事项：不能通过接口实现类的对象来调用接口当中的静态方法。
* 正确用法：通过接口名称，直接调用其中的静态方法。
*         格式： 接口名称.静态方法名(参数)；
* */
public class Demo01Interface {
    public static void main(String[] args) {
        
        // 错误写法。因为：【不能通过接口实现类的对象来调用接口当中的静态方法】

        // MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl(); // 创建了实现类对象
        // impl.methodStatic();
        

        // 直接通过接口名称调用静态方法  静态和对象没关系（【上面的做法为啥new一个对象呢？所以上面的做法错误且没有必要】），但是和类有关系。
        MyInterfaceStatic.methodStatic();


    }
}

• 接口的静态方法

package Static.MyInter;
/*
* 从Java 8开始，接口当中允许定义静态方法：
* 格式：
* public static 返回值类型 方法名称(参数列表) { 方法体 }
*
* 提示：就是将 abstract 或者 default 换成 static 即可，带上方法体。
* */
public interface MyInterfaceStatic {
    public static void methodStatic(){
        System.out.println("这是接口的静态方法");
    }
}

• 是一个类实现一个接口用的关键字：implements

package Static.MyInter;

public class MyInterfaceStaticImpl implements MyInterfaceStatic{

}

接口的私有方法定义和使用

package Static.privateA;
/*
* 问题描述：
* 我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。
* 但是这个共有方法不应该让实现类使用，应该是私有化的。
*
* 解决方案：
* 从Java 9开始，接口当中允许定义私有方法。
* 1.普通私有方法，解决多个默认方法之间重复代码问题
*   格式：private 返回值类型 方法名称(参数列表) { 方法体 }
* 2.静态私有方法，解决多个静态方法之间重复代码问题
*   格式：private static 返回值类型 方法名称(参数列表) { 方法体 }
*
* */
public interface MyInterfacePrivateA {
    public default void methodDefault1() {
        System.out.println("默认方法1");
//        methodCommon();
    }

    public default void methodDefault2() {
        System.out.println("默认方法2");
//        methodCommon();
    }

//    private void methodCommon() {
//        System.out.println("AAA");
//        System.out.println("BBB");
//        System.out.println("CCC");
//    }
}

• MyInterfacePrivateA页面

package Static.privateA;

public class MyInterfacePrivateAImpl implements MyInterfacePrivateA {
    public void methodAnother() {
        // 直接访问到了接口中的默认方法，这样是错误的
        // methodCommon();
    }
}

• MyInterfacePrivateB页面

package Static.privateA;

public interface MyInterfacePrivateB {
    public static void methodStatic1() {
        System.out.println("静态方法1");
//        methodStaticCommon();
    }

    public static void methodStatic2() {
        System.out.println("静态方法2");
//        methodStaticCommon();
    }

//    private static void methodStaticCommon() {
//        System.out.println("AAA");
//        System.out.println("BBB");
//        System.out.println("CCC");
//    }
}

• Demo01Interface页面

package Static.privateA;

public class Demo01Interface {
    public static void main(String[] args) {
        MyInterfacePrivateB.methodStatic1();
        MyInterfacePrivateB.methodStatic2();

        // 错误写法：
        // MyInterfacePrivateB.methodStaticCommon();
    }
}

接口的常量定义和使用

package Const;

public class Demo01Interface {

    public static void main(String[] args) {
        // 访问接口当中的常量
        System.out.println(MyInterfaceConst.NUM_OF_MY_CLASS);
    }

}

package Const;
/*
* 接口当中也可以定义"成员变量"，但是必须使用 public static final 三个关键字进行修饰。
* 从效果上看，这其实就是接口的【常量】
* 格式：  public static final 数据类型 常量名称 = 数据值；
*
* 备注：一旦使用 final 关键字进行修饰，说明不可改变。
*
* 注意事项：
* 1.接口当中的常量，可以省略 public static final，注意：不写也照样是这样。
* 2.接口当中的常量，必须进行赋值；不能不赋值。
* 3.接口中常量的名称，使用完全大写的字母，用下划线进行分隔。(推荐命名规则)
*
* */
public interface MyInterfaceConst {
    // 这其实就是一个常量，一旦赋值，不可以修饰
    public static final int NUM_OF_MY_CLASS = 10;
}

接口的内容小结

继承父类并实现多个接口

package Demo01;
/*
* 使用接口的时候，需要注意：
* 1.接口是没有静态代码块或者构造方法的。
* 2.一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。
* 3.如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
* 4.如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
* 5.如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
* 6.一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。
*
* 格式：
* public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB { // 覆盖重写所有抽象方法 }
* */
public class Demo01Interface {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method(); // 父类方法
    }
}

• 实现类

package Demo01;

// 如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。 【添加关键字 abstract】
public abstract class MyInterfaceAbstract implements MyInterfaceA,MyInterfaceB{
    @Override
    public void methodA() {

    }

    @Override
    public void methodAbs() {

    }

    @Override
    public void methodDefault() {

    }

    // 假设没有覆盖重写这个接口
//    @Override
//    public void methodB() {
//
//    }

}

• 接口

package Demo01;

public interface MyInterface {
    public default void method() {
        System.out.println("接口的默认方法");
    }
}

• MyInterfaceImpl类

package Demo01;

// 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口
public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB{
    @Override
    public void methodA() {
        System.out.println("覆盖重写了A方法");
    }

    @Override
    public void methodAbs() {
        System.out.println("覆盖重写了AB接口都有的抽象方法");
    }

    @Override
    public void methodB() {
        System.out.println("覆盖重写了B方法");
    }

    @Override
    public void methodDefault() {
        System.out.println("对多个接口当中冲突的默认方法进行了覆盖重写");
    }
}

• 接口A

package Demo01;

public interface MyInterfaceA {
    // 错误写法：接口不能有静态代码块
    // static {}

    // 错误写法：接口不能有构造方法
    // public MyInterface{}

    public abstract void methodA();

    public abstract void methodAbs();

    public default void methodDefault() {
        System.out.println("默认方法AAA");
    }

}

• 接口B

package Demo01;

public interface MyInterfaceB {
    // 错误写法：接口不能有静态代码块
    // static {}

    // 错误写法：接口不能有构造方法
    // public MyInterface{}

    public abstract void methodB();

    public abstract void methodAbs();

    public default void methodDefault() {
        System.out.println("默认方法BBB");
    }
}

• 父类

package Demo01;

public class Fu {
    public void method() {
        System.out.println("父类方法");
    }
}

• 子类

package Demo01;

public class Zi extends Fu implements MyInterface{

}

接口之间的多继承

package Demo01.study;
/*
* 1.类与类之间是单继承的，直接父类只有一个；
* 2.类与接口之间是多实现的。一个类可以实现多个接口
* 3.接口与接口之间是多继承的。
*
* 注意事项：
* 1.多个父接口当中的抽象方法如果重复，没关系。
* 2.多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写。【而且带着default关键字】
* */
public class Demo01Relations {

}

package Demo01.study;

public class MyInterfaceImpl implements MyInterface{
    @Override
    public void method() {

    }

    @Override
    public void methodA() {

    }

    @Override
    public void methodB() {

    }

    @Override
    public void methodCommon() {

    }
}

• 子接口

package Demo01.study;

// 接口：含有接口A和接口B的内容，另外还有自己的内容。

/*
*  这个子接口当中有几个方法？答：4个
*  methodA 来源于接口A
*  methodB 来源于接口B
*  methodCommon 来源于接口A和B
*  method  来源于我自己
* */
public interface MyInterface extends MyInterfaceA,MyInterfaceB{
    // 自己的抽象方法
    public abstract void method();

    @Override
    default void methodDefault() {

    }
}

• 接口A

package Demo01.study;

// 接口A
public interface MyInterfaceA {

    // 抽象方法
    public abstract void methodA();

    public abstract void methodCommon();

    public default void methodDefault() {
        System.out.println("AAA");
    }

}

• 接口B

package Demo01.study;

// 接口B
public interface MyInterfaceB {

    // 抽象方法
    public abstract void methodB();

    public abstract void methodCommon();

    public default void methodDefault() {
        System.out.println("BBB");
    }

}

多态的概述

多态的格式与使用

package Multi;

/*
*  代码当中体现多态性，其实就是一句话：父类引用指向子类对象。
*  格式：父类名称 对象名 = new 子类名称(); 或者 接口名称  对象名 = new 实现类名称();
*
* */
public class Demo01Multi {
    public static void main(String[] args) {
        // 使用多态的写法
        // 左侧父类的引用，指向了右侧子类的对象
        Fu obj = new Zi();

        obj.method();  // 子类方法
        obj.methodFu(); // 父类特有方法
    }
}

• 父类

package Multi;

public class Fu {
    // 成员方法
    public void method() {
        System.out.println("父类方法");
    }

    public void methodFu() {
        System.out.println("父类特有方法");
    }
}

• 子类

package Multi;

public class Zi extends Fu{

    // 成员方法
    @Override
    public void method() {
        System.out.println("子类方法");
    }
}

多态中成员变量和成员方法的使用特点

• 运行代码

package Multi.Demo02;
/*
*  在多态的代码当中，成员方法的访问规则是：
*    看new的是谁，就优先用谁，没有则向上找。
*
*  口诀：编译看左边，运行看右边。
*
*  对比一下：
*  成员变量：编译看左边，运行还看左边。
*  成员方法：编译看左边，运行看右边。
*
* */
public class MultiMethod {
    public static void main(String[] args) {
        Fu obj = new Zi(); // 多态

        /*
        *  编译看左边：左边是 Fu obj
        *  1. obj.method(); Fu 当中有method方法 => 运行看右边：但是因为 new Zi() 优先用子类的方法
        *  2. obj.methodFu(); Fu 当中有method方法 => 运行看右边：但是因为 new Zi() 优先用子类的方法,子类没有，父类有。向上找到父类
        * */

        // 父子都有这个方法，但是因为 new Zi() 优先用子类的方法
        obj.method(); // 打印结果：子类方法

        // 子类没有，父类有。向上找到父类
        obj.methodFu();  // 父类特有方法

        // 编译看左边，左边是 Fu obj，Fu当中没有methodZi方法，所以编译报错。
        // obj.methodZi(); // 错误写法!

    }
}

• 成员变量不能进行覆盖重写，只有成员方法可以覆盖重写

package Multi.Demo02;
/*
* 访问成员变量的两种方式：
*
* 1.直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找
* 2.间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找
* */
public class MultiField {
    public static void main(String[] args) {
        // 使用多态的写法，父类引用指向子类对象
        Fu obj = new Zi();
        System.out.println(obj.num); // 父类 10
        System.out.println("==========");

        // 子类没有覆盖重写，就是父类 10
        // 子类如果覆盖重写，就是子类 20
        obj.showNum();
    }
}

• 父类

package Multi.Demo02;

public class Fu {
    int num = 10;

    public void showNum() {
        System.out.println(num);
    }

    public void method() {
        System.out.println("父类方法");
    }

    public void methodFu() {
        System.out.println("父类特有方法");
    }
}

• 子类

package Multi.Demo02;

public class Zi extends Fu{
    int num = 20;

    // 子类覆盖重写
    @Override
    public void showNum() {
        System.out.println(num);
    }

    @Override
    public void method() {
        System.out.println("子类方法");
    }

    public void methodZi() {
        System.out.println("子类特有方法");
    }
}

使用多态的好处

对象的向上、向下转型（instanceof类型判断）

• 代码运行

package obj.Animal.demo01.demo1.animal;

/*
*  向上转型一定是安全的，没有问题的，正确的。但是也有一个弊端：
*  对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。
* */
public class Demo01Main {
    public static void main(String[] args) {
        // 对象的向上转型，就是：父类引用指向子类对象。
        Animal animal = new Cat();
        animal.eat(); // 猫吃鱼

        // 错误写法 【对象一旦向上转型为父类，那么就无法调用子类原本特有的内容】
        // animal.catchMouse();

        // 向下转型，进行 "还原" 动作
        Cat cat = (Cat) animal;
        cat.catchMouse(); // 猫抓老鼠

        /*
        *  下面是错误的向下转型
        *  本来new的时候是一只猫，现在非要当做狗
        *  错误写法! 编译不会报错，但是运行会出现异常：java.lang.ClassCastException 类转换异常
        * */
        // Dog dog = (Dog) animal;
    }
}

• 动物类

package obj.Animal.demo01.demo1.animal;

// 抽象方法所在的类，一定是抽象类
public abstract class Animal {
    public abstract void eat();
}

• 猫类

package obj.Animal.demo01.demo1.animal;

// 猫类
public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    // 子类特有方法
    public void catchMouse() {
        System.out.println("猫抓老鼠");
    }
}

• 狗类

package obj.Animal.demo01.demo1.animal;

// 狗类
public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void watchHouse() {
        System.out.println("狗看家");
    }
}

• 用instanceof关键字进行类型判断

package obj.Animal.demo01.demo1.animal;

/*
*  如何才能知道一个父类引用的对象，本来是什么子类？
*  格式： 对象 instanceof 类名称
*  这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例
*
* */
public class Demo02Instanceof {
    public static void main(String[] args) {
        Animal animal = new Cat(); // 本来是一只猫
        animal.eat(); // 猫吃鱼

        /*
        *  如果希望调用子类特有方法，需要向下转型
        *  判断一下父类引用 animal 本来是不是Dog
        * */
        if (animal instanceof  Dog) {
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        // 判断一下 animal 本来是不是Cat
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse(); // 猫抓老鼠
        }
		
        // 给我一个动物
        giveMeAPet(new Dog());
    }

    public static void giveMeAPet(Animal animal) {
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.watchHouse(); // 狗看家
        }
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }
    }
}

多态综合案例：笔记本电脑接口

接口的基本使用–对象的上下转型–使用接口作为方法的参数

package obj.Animal.demo01.demo1.USB;

public class DemoMain {
    public static void main(String[] args) {
        // 首先创建一个笔记本电脑
        Computer computer = new Computer();
        computer.powerOn();

        // 准备一个鼠标，供电脑使用：首先进行向上转型
        USB usbMouse = new Mouse();
        // 参数是USB类型，我正好传递进去的就是USB鼠标
        computer.useDevice(usbMouse);

        // 创建一个USB键盘
        Keyboard keyboard = new Keyboard(); // 没有使用多态写法
        // 方法参数是USB类型，传递进去的是实现类对象
        computer.useDevice(keyboard); // 正确写法，发生了向上转型
        // 使用子类对象，匿名对象，也可以
        computer.useDevice(new Keyboard()); // 正确写法

        computer.powerOff();
        System.out.println("============");

        method(10.0); // 正确写法：double ---> double
        method(20); // 正确写法：int ---> double
        int a = 30;
        method(a); // 正确写法：int ---> double
        computer.powerOff();
    }

    public static void method(double num) {
        System.out.println(num);
    }
}

• 电脑

package obj.Animal.demo01.demo1.USB;

// 电脑
public class Computer {

    public void powerOn() {
        System.out.println("笔记本电脑开机");
    }

    public void powerOff() {
        System.out.println("笔记本电脑关机");
    }

    // 使用USB设备的方法，使用接口作为方法的参数
    public void useDevice(USB usb) {
        usb.open(); // 打开设备
        if (usb instanceof Mouse) { // 一定要先判断
            Mouse mouse = (Mouse) usb; // 向下转型
            mouse.click();
        } else if (usb instanceof Keyboard) { // 先判断
            Keyboard keyboard = (Keyboard) usb; // 向下转型
            keyboard.type();
        }
        usb.close(); // 关闭设备
    }
}

• usb 抽象类

package obj.Animal.demo01.demo1.USB;

// usb 抽象类
public abstract class USB {

    public abstract void open(); // 打开设备
    public abstract void close(); // 关闭设备
}

• 鼠标

package obj.Animal.demo01.demo1.USB;

// 鼠标就是一个USB设备
public class Mouse extends USB {

    @Override
    public void open() {
        System.out.println("打开鼠标");
    }

    @Override
    public void close() {
        System.out.println("关闭鼠标");
    }

    public void click() {
        System.out.println("鼠标点击");
    }
}

• 键盘

package obj.Animal.demo01.demo1.USB;

// 键盘就是一个USB设备
public class Keyboard extends USB {

    @Override
    public void open() {
        System.out.println("打开键盘");
    }

    @Override
    public void close() {
        System.out.println("关闭键盘");
    }

    public void type() {
        System.out.println("键盘输入");
    }
}

final关键字

• final关键字-修饰类

package obj.Animal.demo01.demo1.Final;

/*
*  当final关键字用来修饰一个类的时候，格式：
*  public final class 类名称 { 方法体 }
*
*  含义：当前这个类不能有任何的子类。（太监类）
*  注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没儿子）
* */
public final class MyClass {
    public void method() {
        System.out.println("方法执行");
    }
}

• 父类：final关键字-修饰成员方法

package obj.Animal.demo01.demo1.Final;

/*
*  当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
*  格式： 修饰符 final 返回值类型 方法名称(参数列表) { 方法体 }
*
*  注意事项：
*  1.对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。
*  */
public abstract class Fu {
    public final void method() {
        System.out.println("父类方法执行");
    }

    public abstract /*final*/ void methodAbs();
}

• 子类

package obj.Animal.demo01.demo1.Final;

public class Zi extends Fu{
    @Override
    public void methodAbs() {

    }

    // 错误写法：不能覆盖重写父类当中final的方法
//    @Override
//    public void method() {
//        System.out.println("子类覆盖重写父类的方法");
//    }
}

• final关键字-修饰局部变量

package obj.Animal.demo01.demo1.Final;
/*
*  final关键字代表最终、不可改变的。
*
*  常见四种用法：
*  1.可以用来修饰一个类
*  2.可以用来修饰一个方法
*  3.还可以用来修饰一个局部变量
*  4.还可以用来修饰一个成员变量
* */
public class Demo01Final {
    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(num1); // 10

        num1 = 20;
        System.out.println(num1); // 20

        /*
        *  一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。
        *  一次赋值，终生不变
        * */
        final int num2 = 200;
        System.out.println(num2); // 200

//        num2 = 250; // 错误写法：不能改变
//        num2 = 200; // 错误写法：即使赋值为原值200，也不可以!!!

        // 正确写法：只要保证有唯一一次赋值即可
        final int num3;
        num3 = 30;

        /*
        *  对于基本类型来说，不可变说的是变量当中的数据不可改变。
        *  对于引用类型来说，不可变说的是变量当中的地址值不可改变。
        * */
        Student stu1 = new Student("赵丽颖");
        System.out.println(stu1); // obj.Animal.demo01.demo1.Final.Student@1540e19d
        System.out.println(stu1.getName()); // 赵丽颖
        stu1 = new Student("霍建华");
        System.out.println(stu1); // obj.Animal.demo01.demo1.Final.Student@677327b6
        System.out.println(stu1.getName()); // 霍建华
        System.out.println("=======================");

        final Student stu2 = new Student("刘诗诗");
        // stu2 = new Student("吴奇隆"); // 错误写法! final的引用类型变量，其中的地址不可改变

        System.out.println(stu2.getName()); // 刘诗诗
        stu2.setName("诗爷");
        System.out.println(stu2.getName()); // 诗爷
    }
}

• Person类：final关键字-修饰成员变量

package obj.Animal.demo01.demo1.Final;

/*
*  对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。
*  1.由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
*  2.对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一
*  3.必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。
* */
public class Person {

    private final String name;

    // 无参构造
    public Person() {
        name = "刘诗诗";
    }

    // 有参构造
    public Person(String name) {
        this.name = name;
    }

    // Getter/Setter方法
    public String getName() {
        return name;
    }

//    public void setName(String name) {
//        this.name = name;
//    }
}

• 学生类

package obj.Animal.demo01.demo1.Final;

// 学生类
public class Student {
    private String name;

    // 无参构造
    public Student() {

    }
    // 有参构造
    public Student(String name) {
        this.name = name;
    }

    // Getter/Setter方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

四种权限修饰符

Java中有四种权限修饰符： (权限：从大到小)
public > protected > (default) > private

注意：(default) 并不是关键字"default"，而是根本不写。

-	public	protected	(default)	private
同一个类（我自己）	√	√	√	√
同一个包（我邻居）	√	√	√	×
不同包子类（我儿子）	√	√	×	×
不同包非子类（陌生人）	√	×	×	×

成员内部类的定义和使用

package wd01.demo01;
/*
*  如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。
*  例如：汽车和发动机的关系。
*
*  分类：
*  1.成员内部类
*  2.局部内部类（包含匿名内部类）
*
* 成员内部类的定义格式：
* 修饰符 class 外部类名称 {
*       修饰符 class 内部类名称 {
*           // ...
*       }
*       // ...
* }
*
* 注意：内用外，随意访问；外用内，需要内部类对象。
* =====================
* 如何使用成员内部类？有两种方式：
* 1.间接方式：在外部类的方法当中，使用内部类；然后main只是调用外部类的方法。
* 2.直接方式：
*   类名称 对象名 = new 类名称();
*   外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
* */
public class Demo01InnerClass {
    public static void main(String[] args) {
        Body body = new Body(); // 外部类的对象
        // 通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heart
        body.methodBody();
        System.out.println("========");
        // 按照公式写：
        Body.Heart heart = new Body().new Heart();
        heart.beat();
    }
}

package wd01.demo01;

public class Body {

    // 外部类的成员变量
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public class Heart {
        // 内部类的方法
        public void beat() {
            System.out.println("心脏跳动");
            System.out.println("我叫：" + name); // 正确写法
        }
    }
    // 外部类的方法
    public void methodBody() {
        System.out.println("外部类的方法");
        // 在外部类的方法里面，创建内部类对象
        Heart heart = new Heart();
        heart.beat();
    }
}

内部类的同名变量访问

package wd01.demo01;

public class Demo02InnerClass {
    public static void main(String[] args) {
        // 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
        Outer.Inner obj = new Outer().new Inner();
        obj.methodInner();
    }
}

package wd01.demo01;
// 如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名
public class Outer {

    int num = 10; // 外部类的成员变量

    public class Inner {
         int num = 20; // 内部类的成员变量
         public void methodInner() {
             int num = 30; // 内部类方法的局部变量
             System.out.println(num); // 局部变量，就近原则 30
             System.out.println(this.num); // 内部类的成员变量 20
             System.out.println(Outer.this.num); // 外部类的成员变量 10
         }
    }
}

局部内部类的final问题

package wd01.demo01.Outes;
/*
*  局部内部类：如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】
*
* 备注：从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略。
*
* 原因：
* 1.new出来的对象在堆内存当中。
* 2.局部变量是跟着方法走的，在栈内存当中。
* 3.方法运行结束之后，立刻出栈，局部变量就会立刻消失。
* 4.但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。
* */
public class MyOuter {
    public void methodOuter() {
        final int num = 10; // 所在方法的局部变量
        class MyInner {
            public void methodInner() {
                System.out.println(num);
            }
        }
    }
}

匿名内部类【重点】

package wd01.demo01.niName;
/*
*  如果接口的实现类（或者是父类的子类）只需要使用唯一的一次。
*  那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】
*
*  匿名内部类的定义格式：
*  接口名称 对象名 = new 接口名称() {
*       // 覆盖重写所有抽象方法
*  }
*
* 对格式 "new 接口名称() { ... }"进行解析：
* 1.new 代表创建对象的动作
* 2.接口名称就是匿名内部类需要实现哪个接口
* 3.{ ... }这才是匿名内部类的内容
*
* 另外还有注意几点问题：
* 1.匿名内部类，在创建对象的时候，只能使用唯一一次。
* 如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了。
* 2.匿名对象，在【调用方法】的时候，只能调用唯一一次。
* 如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
* 3.匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
* 强调：匿名内部类和匿名对象不是一回事儿!!!
* */
public class DemoMain {
    public static void main(String[] args) {
//        MyInterfaceImpl impl = new MyInterfaceImpl();
//        impl.method();

        // 使用匿名内部类
        MyInterface objA = new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类实现了方法");
            }
        };
        objA.method();
        System.out.println("===========");

        // 使用了匿名内部类，而且省略了对象名称，也是匿名对象
        new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类实现了方法");
            }
        }.method();
    }
}

package wd01.demo01.niName;

public interface MyInterface {
    public abstract void method(); // 抽象方法
}

类作为成员变量类型

package wd01.demo01.Heros;

public class DemoMain {
    public static void main(String[] args) {
        // 创建一个英雄角色
        Hero hero = new Hero();
        // 为英雄起一个名字，并且设置年龄
        hero.setName("盖伦");
        hero.setAge(20);

        // 创建一个武器对象
        Weapon weapon = new Weapon("圣剑");
        // 为英雄配备武器
        hero.setWeapon(weapon);
        // 攻击
        hero.attack();
    }
}

• 英雄

package wd01.demo01.Heros;
/*
*  游戏当中的英雄角色类
* */
public class Hero {
    private String name; // 英雄名字
    private int age; // 英雄的年龄
    private Weapon weapon; // 英雄的武器

    public Hero() {

    }

    public Hero(String name, int age, Weapon weapon) {
        this.name = name;
        this.age = age;
        this.weapon = weapon;
    }
    // 攻击敌人
    public void attack() {
        System.out.println("年龄为" + age + "的" + name + "用" + weapon.getCode() + "攻击敌方");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Weapon getWeapon() {
        return weapon;
    }

    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }
}

• 武器

package wd01.demo01.Heros;

public class Weapon {
    private String code; // 武器的代号

    public Weapon() {
    }

    public Weapon(String code) {
        this.code = code;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}

接口作为成员变量类型

package wd01.demo01.implement;

public class DemoGame {
    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.setName("艾希"); // 设置英雄的名称

        // 设置英雄技能--使用单独定义的实现类
        hero.setSkill(new SkillImpl());

        // 还可以改成使用匿名内部类
        Skill skill = new Skill() {
            @Override
            public void use() {
                System.out.println("呯呯呯");
            }
        };
        hero.setSkill(skill);

        // 进一步简化，同时使用匿名内部类和匿名对象
        hero.setSkill(new Skill() {
            @Override
            public void use() {
                System.out.println("喵喵喵~");
            }
        });
        // 攻击敌人
        hero.attack();
    }
}

package wd01.demo01.implement;

public class Hero {
    private String name; // 英雄的名称
    private Skill skill; // 英雄的技能

    public Hero() {
    }

    public Hero(String name, Skill skill) {
        this.name = name;
        this.skill = skill;
    }

    public void attack() {
        System.out.println("我叫" + name + "开始释放技能");
        skill.use(); // 调用接口中的抽象方法
        System.out.println("释放技能完成");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Skill getSkill() {
        return skill;
    }

    public void setSkill(Skill skill) {
        this.skill = skill;
    }
}

package wd01.demo01.implement;

public class SkillImpl implements Skill{

    @Override
    public void use() {
        System.out.println("咚咚咚~");
    }
}

package wd01.demo01.implement;

public interface Skill {
    void use(); // 释放技能的抽象方法
}

接口作为方法的参数和返回值

package wd01.demo01.implement;

import java.util.ArrayList;
import java.util.List;

/*
*  java.util.list 正是ArrayList所实现的接口
* */
public class DemoInterface {
    public static void main(String[] args) {
        // 左边是接口名称，右边是实现类名称，这就是多态写法
        List<String> list = new ArrayList<>();

        List<String> result = addNames(list);
        for (int i = 0; i < result.size(); i++) {
            System.out.println(result.get(i));
        }
    }

    public static List<String> addNames(List<String> list) {
        list.add("迪丽热巴");
        list.add("古力娜扎");
        list.add("马尔扎哈");
        list.add("沙扬娜拉");
        return list;
    }
}