Java继承和多态

1,继承

(1),

关键字 extends

public class Employee {
}
public class Assistant extends Employee {

}

(2),在父子的继承的关系当中，若果重命则创建子类对象的时候，有两种方式

(a),直接通过子类对象访问成员变量, 等号左边是谁优先用谁
(b),间接通过成员方法访问成员变量

public static void main(String[] args) {
        Fu fu = new Fu();
        System.out.println(fu.numFu);

        Zi zi = new Zi();
        System.out.println(zi.numFu);
        System.out.println(zi.numZi);
        System.out.println("===============");

        System.out.println(zi.num); //优先子类 200
//        System.out.println(zi.abc); //到处都没有
        System.out.println("===============");

        //这个方法是子类，优先用子类的。没有在向上找
        zi.methodZi();//200
        //这个方法是父类的
        zi.methodFu();//100

(3),变量的使用

局部变量；直接写
本类的成员变量： this.成员变量
父类的成员变量： super.成员变量

public class Fu {
    int num = 10;
}
public class Zi extends Fu{
    int num = 20;
    public void method(){
        int num = 30;
        System.out.println(num); //30
        System.out.println(this.num); //20
        System.out.println(super.num); //10
    }
}
public class Demo01ExtendsFiled {
    public static void main(String[] args) {
        Zi zi = new Zi();

        zi.method();
    }
}

(4),在父子类的继承关系当中，创建子类对象访问成员方法的规则

注意事项：
无论是成员方法还是成员变量，如果没有都是向上找父类，绝不会向下找子类

重写 (OverWrite):方法名称一样，参数列表也一样
重载 (Overload)：方法名称一样，参数列表不一样

public class Fu {
    public void methodFu(){
        System.out.println("父类方法执行！");
    }

    public void method(){
        System.out.println("父类重名方法执行!");
    }
}
public class Zi extends Fu {
    public void methodZi(){
        System.out.println("子类执行！");
    }
    public void method(){
        System.out.println("子类重名方法执行!");
    }
}
public class Demo01extendsMethod {
    public static void main(String[] args) {
        Zi zi = new Zi();

        zi.methodZi();
        zi.methodFu();

        //创建的是new子类对象，所以优先用子类
        zi.method();

    }
}

(5),方法覆盖重写的注意事项

1，必须保证父子类之间的方法名称相同，参数列表也相同，@Override 写在方法前面，用来检测是不是有效的重写，这个注解不写也是对的。
2，子类方法的返回值，必须[小于等于]父类方法得返回值得范围，Object类是所有类的公共最高父类(祖宗类) java.lang.String 是object得子类
3,子类方法得权限必须大于等于父类权限修饰符，public > Protect > (default) > private，default 是什么都不写，空着

public class Demo01OverWrite {
}

class Fu{
    public Object method(){
        return null;
    }
}

class Zi extends Fu{
    @Override
    public Object method(){
        return null;
    }
}

(6),父子类构造方法得访问特点

1，子类构造方法中有一个默认得"super()"调用，什么都没写，默认赠送。
2，可以通过super关键字来子类构造调用父类重载构造
3,super的父类构造调用，必须是子类构造方法得第一个语句。不能一个子类构造，调用多个父类构造
总结：
子类必须调用父类构造方法，不写则赠送super，写了则调用指定的super调用，super只能有一个，还必须是第一个

public class Demo01Constructor {
    public static void main(String[] args) {
        Zi zi = new Zi();

    }
}

class Fu{
    public Fu(){

    }
    public Fu(int num){
        System.out.println("父类构造方法");
    }
}

class Zi extends Fu{
//      super();隐藏的
    public Zi(){
        super(10);
        //super(16);
        System.out.println("子类构造方法");
    }
    public void method(){
//        super(10);  写法错误！只有子类构造方法，才能调用父类构造方法。
    }
}

(7),super 关键字的用法三种：

1,在子类的成员方法中，访问父类的成员变量。
2,在子类的成员方法中，调用父类的成员方法。
3,在子类的构造方法中，访问父类的构造方法。

(8),super 关键字用来访问父类内容，this关键字用来访问本类内容，用法三种

1，在本类的成员方法中，访问本类成员变量
2，在本类的成员方法中，访问本类的另一个成员方法
3，在本类的构造方法中，访问苯类的另一个构造方法
this方法也必须是构造方法的第一个语句。
super 和 this 两种构造不能同时使用。

public class Fu {
    int num = 30;
}
public class Zi extends Fu {
    int num = 20;
    public Zi(){
        this(123);//本类的无参构造，调用本类的有参构造。
    }
    public Zi(int num){

    }
    public Zi(int n, int m){

    }
    public void showNum(){
        int num = 10;
        System.out.println(num);//局部变量
        System.out.println(this.num);//本类变量
        System.out.println(super.num );//父类中的成员变量

    }

    public void methodA(){
        System.out.println("AAA");
    }
    public void methodB(){
        this.methodA();
        System.out.println("BBB");
    }
}

2，抽象类

(1),

1，不能直接创建抽象类对象。
2，必须用一个子类继承父类。
3，子类必须覆盖重写抽象父类当中的所有抽象方法。覆盖重写(实现)，子类去掉抽象方法的abstract关键字，然后补上方法大括号。
4，常见子类对象。

public abstract class Animal {
    public abstract void eat();

    public void method(){

    }
}
public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("吃骨头");
    }
}
public class DemoMain {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
    }
}

(2),

一个抽象方法不一定非得有抽象类，只要保证抽象方法在抽象类里就行.

public abstract class MyAbstract {
}

(3),抽象类的应用

//最高的抽像父类 
public abstract class Animal {

    public abstract void sleep();
    public abstract void eat();
}

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

class DogGolden extends Dog {
    @Override
    public void sleep(){
        System.out.println("呼呼呼。。。。");
    }
}

class Dog2H extends Dog{
    @Override
    public void sleep(){
        System.out.println("嘿嘿嘿。。。");
    }
}

class DemoMain{
    public static void main(String[] args) {
        DogGolden dogGolden = new DogGolden();
        dogGolden.eat();
        dogGolden.sleep();
    }
}

(4),发红包案例

import java.util.ArrayList;
import java.util.Random;

public class Member extends User {
    public Member() {
    }

    public Member(String name, int money) {
        super(name, money);
    }

    public void receive(ArrayList<Integer> list) {
        //从多个红包里抽取一个
        //随机获取一个索引编号
        int index = new Random().nextInt(list.size());
        //从集合当中删除，并得到被删除的红包给我自己
        Integer date = list.remove(index);
        //当前成员有多少钱
        int money = super.getMoney();
        //加上，并重新设置回去
        super.setMoney(money + date);
    }
}
import java.util.ArrayList;
import java.util.Random;

public class Member extends User {
    public Member() {
    }

    public Member(String name, int money) {
        super(name, money);
    }

    public void receive(ArrayList<Integer> list) {
        //从多个红包里抽取一个
        //随机获取一个索引编号
        int index = new Random().nextInt(list.size());
        //从集合当中删除，并得到被删除的红包给我自己
        Integer date = list.remove(index);
        //当前成员有多少钱
        int money = super.getMoney();
        //加上，并重新设置回去
        super.setMoney(money + date);
    }
}
import java.util.ArrayList;

public class Manager extends User {
    public Manager(){

    }

    public Manager(String name, int money) {
        super(name, money);
    }

    public ArrayList<Integer> send(int totalMoney, int count ) {
        //需要一个集合，用来储存若干个红包的金额
        ArrayList<Integer> redList = new ArrayList<>();
        //看一下群主有多少钱
        int leftMoney = super.getMoney();
        if(totalMoney > leftMoney) {
            System.out.println("余额不足！");
            return redList;
        }
        //扣钱
        super.setMoney(leftMoney - totalMoney);
        //发红包，分成多少分
        int avg = totalMoney / count;
        int mod = totalMoney % count;//余额，也就是甩下的零头
        //剩下的零头，摆在最后一个红包里
        //把红包放到集合里
        for (int i = 0; i < count - 1; i++) {
            redList.add(avg);
        }
        //最后一个红包
        int last = avg + mod;
        redList.add(last);

        return redList;
    }
}
import java.util.ArrayList;

public class MainRedPacket {
    public static void main(String[] args) {
        Manager manager = new Manager("群主",100);
        Member  one = new Member("成员A",0);
        Member  two = new Member("成员B",0);
        Member  three = new Member("成员C",0);
        manager.show();
        one.show();
        two.show();
        three.show();
        System.out.println("==================");

        ArrayList<Integer> redList = manager.send(20,3);

        one.receive(redList);
        two.receive(redList);
        three.receive(redList);
        manager.show();
        one.show();
        two.show();
        three.show();
    }
}

3,接口

(1),

接口就是多个类的公共规范。
接口就是一种引用类型，最重要的内容，就是抽象方法
定义一个接口的方法
public interface 接口名称 {
//接口的内容
}

备注：换成了关键字 interface之后，编译器生成的字节码文件仍然是：.java --> .class

java7 接口内的内容包括：
1，常量
2，抽象方法

如果是java8 还可以额外包含有
3，默认方法
4，静态方法
java9
5，私有方法

接口使用步骤
1，接口不能直接使用，必须有一个实现类实现接口。
格式：
public class 实现类名称 implements 接口名称 {
//实现..........
}
2，接口的实现类必须覆盖重写接口所有的抽象类
3，创建实现类的对象，进行使用。

注意事项：
如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是一个抽象类。

/*
抽象方法
public abstract 返回值类型 方法名称（参数列表）;

注意事项：
1，接口当中的抽象方法，修饰符必须是两个固定的关键字， Public abstract
2，这两个关键字的修饰符，可以选则性的省略。(今天新学不推荐)
 */
public interface MyInterFaceAbstract {
    //抽象方法
    public abstract void methodAbstract1();
    void methodAbstract2();  //这也是抽象类

}
public class MyInterfaceAbstractImpl implements MyInterFaceAbstract {
    @Override
    public void methodAbstract1() {
        System.out.println("这是第一个方法。");
    }
    @Override
    public void methodAbstract2() {
        System.out.println("这是第二个方法。");
    }

}
public class Demo01InterFace {
    public static void main(String[] args) {
        //创建实现类使用
        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        impl.methodAbstract1();
        impl.methodAbstract2();
    }

}

(2),默认方法

1，接口的默认方法，可以被接口的实现类对象，直接调用
2，接口的默认方法，可以被接口的实现类进行覆盖重写

package cn.itcast.day10.demo01;
/*
从Java8 开始，接口允许定义默认方法
格式：
public default 返回值类型 方法名称 {
       方法体
}
备注：
接口中的默认方法，可以解决接口升级的问题
 */
public interface MyInterfaceDefault {
    //抽象方法
    public abstract void methodAbs ();
    //新添加了一个抽象方法
//    public abstract void methodAbs2 ();
    public default void methodDefault () {

        System.out.println("这是新添加的默认方法");
    }
}
package cn.itcast.day10.demo01;

public class MyInterfaceDefaultA implements MyInterfaceDefault{
    @Override
    public void methodAbs() {
        System.out.println("实现了方法AAA");
    }
}

package cn.itcast.day10.demo01;

public class MyInterfaceDefaultB implements MyInterfaceDefault{
    @Override
    public void methodAbs() {
        System.out.println("实现了方法BBB");
    }

    @Override
    public void methodDefault() {
        System.out.println("实现了类B的覆盖重写");
    }
}
public class Demo02IInterfaceDefault {
    public static void main(String[] args) {
        MyInterfaceDefaultA a = new MyInterfaceDefaultA();
        a.methodAbs();//调用抽象方法，实施运行的是右侧实现类
        //调用默认方法，如果实现类中没有，会向上找接口
        a.methodDefault();


        MyInterfaceDefaultB b = new MyInterfaceDefaultB();
        b.methodAbs();
        b.methodDefault();
    }
}

(3),静态方法

不能通过接口实现类的对象来调用接口中的静态问题。

正确用法：通过接口名称直接调用其中的静态方法。

/*
Java8 开始，接口中准许定义静态方法
格式：
public static 返回值类型 方法名称(参数列表) {
    方法体；
}
 */
public interface MyInterfaceStatic {
    public static void methodStatic(){
        System.out.println("这是接口的静态方法！");
    }
}
package cn.itcast.day10.demo01;

public class MyInterfaceStaticImpl implements MyInterfaceStatic{

}
public class Demo03InterfaceStatic {
    public static void main(String[] args) {
//        MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();
        //错误写法！
//        impl.methodStatic;
        //调用静态方法
        MyInterfaceStatic.methodStatic();
    }
}

(4), 私有方法

问题描述：
我们需要抽取出来一个公共方法，用来解决默认方法之间的重复代码问题
但是这个公共方法不应该上实现类使用，私有化

定义私有方法：
1，普通私有方法。解决默认方法之间的代码重复问题。
2，静态私有方法。解决静态方法之间的代码重复问题。

public interface MyInterfacePrivateA {
    public default void methodPrivate1() {
        System.out.println("默认方法1！");
        methodCommon();
    }
    public default void methodPrivate2() {
        System.out.println("默认方法2！");
        methodCommon();
    }
    private void methodCommon() {
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}
public class MyInterfacePrivateAImpl implements MyInterfacePrivateA {
    public void methodAnother() {
        System.out.println("实现类方法！");
    }

}
public class Demo04InterfacePrivate {
    public static void main(String[] args) {
        MyInterfacePrivateAImpl impl = new MyInterfacePrivateAImpl();
        impl.methodPrivate1();
        impl.methodPrivate2();
        impl.methodAnother();

    }
}

(6),常量

final 关键子的作用
如果引用为基本数据类型，则该引用为常量，该值无法修改；
如果引用为引用数据类型，比如对象、数组，则该对象、数组本身可以修改，但指向该对象或数组的地址的引用不能修改。
如果引用时类的成员变量，则必须当场赋值，否则编译会报错。

接口中可以定义“成员变量”，这个成员变量必须使用public static final 三个关键字来修饰。
从效果上看就是接口的【常量】。

public static final 数据类型常量量名称 = 数据值;
注意事项：
1，接口中的常量可以省略 public static final ，注意，不写照样是这一样
2，接口谱中的的常量必须赋值，不能不赋值。
3,接口中的常量的名称全用大写，并且用下划线分割。

public interface MyInterfaceConst {
    //这就是一个常量，一旦赋值，不可修改
    public static final int NUM_Of_CLASS = 10;
}
public class Demo05InterfaceConst {
    public static void main(String[] args) {
        //访问接口中的常量
        System.out.println(MyInterfaceConst.NUM_Of_CLASS);
    }
}

(7),接口的使用

使用接口的时候需要注意
1，接口没有静态代码块，或者构造方法的。
2，一个类的直接父类只有一个，但是一个类可以同时实现多个接口
格式；
public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB{
//覆盖重写所用抽象方法

}
3，如果实现类所实现的多个接口当中，存在重复的抽象方法，那麽只需要覆盖重写一次即可
4，如果实现类没有完全覆盖重写所有接口的的抽象方法，那么这个类必须是抽象类。
5，如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类必须对冲突的默认方法覆盖重写。
6.一类若果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法

package cn.itcast.day10.demo02;

public interface MyInterface {

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

    public void method(){
        System.out.println("父类方法！");
    }
}
package cn.itcast.day10.demo02;

public class Zi extends Fu implements MyInterface {

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

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

//    }

    public abstract void methodA();

    public abstract void methodAbs();

    public default void methodDefault(){
        System.out.println("默认方法AAAAA");
    }
}
public interface MyInterfaceB {
    //错误写法  接口不能有静态代码块
//    static {

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

//    }

    public abstract void methodB();

    public abstract void methodAbs();

    public default void methodDefault(){
        System.out.println("默认方法BBBBB");
    }
}
public class MyInterfaceImpl /*extends Object*/ implements MyInterfaceA, MyInterfaceB {

    @Override
    public void methodA() {
        System.out.println("覆盖重写了A！");
    }

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

    @Override
    public void methodDefault() {
        System.out.println("对多个接口冲突的默认方法惊醒覆盖重写");
    }
}
public abstract class MyInterfaceAbstract implements MyInterfaceA, MyInterfaceB{

    @Override
    public void methodA() {

    }

    @Override
    public void methodAbs() {

    }

    @Override
    public void methodDefault(){
        System.out.println();
    }
}
public class Demo01Interface {
    public static void main(String[] args) {
        MyInterfaceImpl impl = new MyInterfaceImpl();
        impl.methodDefault();

        Zi zi = new Zi();
        zi.method();
    }
}

(8),

类与类之间是单继承的，直接父类只能有一个。
类与接口之间是对实现的。一个类可以实现多个接口。
接口与接口之间是多继承的，

public interface MyInterfaceA {

   public abstract void methodA();
   public abstract void methodCommon();
}
public interface MyInterfaceB {

   public abstract void methodB();
   public abstract void methodCommon();
}
/*
这个子接口中有几个方法？
4个 methodA 来源于接口A methodB 来源于接口B methodCommon 来源于接口A和B

*/
public interface MyInterface extends MyInterfaceA, MyInterfaceB {

   public abstract void method();
}
public class Demo01Relations {
   public static void main(String[] args) {

   }
}

4，多态

(1),定义

代码当中体现多态性，其实就是一句话：父类引用指向子类对象。

格式：
父类名称对象名 = new 子类名称();
或者：
接口名称对象名 = new 实现类名称();

public class Demo01Multi {
    public static void main(String[] args) {
        // 使用多态的写法
        // 左侧父类的引用，指向了右侧子类的对象
        Fu obj = new Zi();

        obj.method();
        obj.methodFu();
    }
}

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

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

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

(2)，多态的使用

访问成员变量的两种方式：

直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找。
间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找。

public class DEmo01MultiField {
    public static void main(String[] args) {
        // 使用多态的写法，父类引用指向子类对象
        Fu obj = new Zi();
        System.out.println(obj.num); // 父：10
//        System.out.println(obj.age); // 错误写法！
        System.out.println("=============");

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

}
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("父类特有方法");
    }
}
public class Zi extends Fu {
    int num = 20;

    int age = 16;

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

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

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

在多态的代码当中，成员方法的访问规则是：
看new的是谁，就优先用谁，没有则向上找。

口诀：编译看左边，运行看右边。

对比一下：
成员变量：编译看左边，运行还看左边。
成员方法：编译看左边，运行看右边。

public class Demo02MultiMethod {
    public static void main(String[] args) {
        Fu obj = new Zi(); // 多态

        obj.method(); // 父子都有，优先用子
        obj.methodFu(); // 子类没有，父类有，向上找到父类

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

}

(3),多态的使用

向上转型一定是安全的，没有问题的，正确的。但是也有一个弊端：
对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。

解决方案：用对象的向下转型【还原】。

如何才能知道一个父类引用的对象，本来是什么子类？
格式：
对象 instanceof 类名称
这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例。

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

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

    public void watchHouse() {
        System.out.println("狗看家");
    }
}
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;
    }
}
public class Demo02Instanceof {
    public static void main(String[] args) {
        Animal animal = new Dog(); // 本来是一只狗
        animal.eat(); // 狗吃SHIT

        // 如果希望掉用子类特有方法，需要向下转型
        // 判断一下父类引用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();
        }
    }
}

(4),多态的练习

1，进行描述笔记本类，实现笔记本使用USB鼠标、USB键盘
2，USB接口，包含开启功能、关闭功能笔记本类，包含运行功能、关机功能、使用3，USB设备功能鼠标类，要实现USB接口，并具备点击的方法键盘类，要实现4USB接口，具备敲击的方法

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(); // 关闭设备
    }
}

public interface USB {
    public abstract void open(); // 打开设备

    public abstract void close(); // 关闭设备

}

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

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

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

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

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

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

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

        // 准备一个鼠标，供电脑使用
//        Mouse mouse = new Mouse();
        // 首先进行向上转型
        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
    }

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

5，final关键字

(1),final关键字代表最终、不可改变的。

常见四种用法：

可以用来修饰一个类
可以用来修饰一个方法
还可以用来修饰一个局部变量
还可以用来修饰一个成员变量

final修饰一个类：
当final关键字用来修饰一个类的时候，格式：
public final class 类名称 {
// ...
}

含义：当前这个类不能有任何的子类。（太监类）
注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没儿子。）

public final class MyClass /*extends Object*/ {

    public void method() {
        System.out.println("方法执行！");
    }
}

// 不能使用一个final类来作为父类
public class MySubClass /*extends MyClass*/ {
}

final修饰一个方法：
当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
格式：
修饰符 final 返回值类型方法名称(参数列表) {
// 方法体
}

注意事项：
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。

public abstract class Fu {

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

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

}

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

    }

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

final修饰局部变量和成员变量
对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。

由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。
必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。

public class Person {

    private final String name/* = "鹿晗"*/;

    public Person() {
        name = "关晓彤";
    }

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

    public String getName() {
        return name;
    }

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

public class Student {

    private String name;

    public Student() {
    }

    public Student(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

6，权限修饰符 day11-code demo02

Java中有四种权限修饰符：
public > protected > (default) > private
同一个类（我自己） YES YES YES YES
同一个包（我邻居） YES YES YES NO
不同包子类（我儿子） YES YES NO NO
不同包非子类（陌生人） YES NO NO NO

注意事项：(default)并不是关键字“default”，而是根本不写。

7，内部类

(1),内部类的定义。

如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。
例如：身体和心脏的关系。又如：汽车和发动机的关系。

分类：

成员内部类
局部内部类（包含匿名内部类）

成员内部类的定义格式：
修饰符 class 外部类名称 {
修饰符 class 内部类名称 {
// ...
}
// ...
}

注意：内用外，随意访问；外用内，需要内部类对象。

==========================
如何使用成员内部类？有两种方式：

间接方式：在外部类的方法当中，使用内部类；然后main只是调用外部类的方法。
直接方式，公式：
类名称对象名 = new 类名称();
【外部类名称.内部类名称对象名 = new 外部类名称().new 内部类名称();】

类的定义：

public class Body { // 外部类

    public class Heart { // 成员内部类

        // 内部类的方法
        public void beat() {
            System.out.println("心脏跳动：蹦蹦蹦！");
            System.out.println("我叫：" + name); // 正确写法！
        }

    }

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

    // 外部类的方法
    public void methodBody() {
        System.out.println("外部类的方法");
        new Heart().beat();
    }

测试类

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();
    }

}

重名时

public class Outer {

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

    public class Inner /*extends Object*/ {

        int num = 20; // 内部类的成员变量

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

    }

}

public class Demo02InnerClass {

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

}

(2),局部内部类

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。

定义格式：
修饰符 class 外部类名称 {
修饰符返回值类型外部类方法名称(参数列表) {
class 局部内部类名称 {
// ...
}
}
}

小节一下类的权限修饰符：
public > protected > (default) > private
定义一个类的时候，权限修饰符规则：
1. 外部类：public / (default)
2. 成员内部类：public / protected / (default) / private
3. 局部内部类：什么都不能写

class Outer {

    public void methodOuter() {
        class Inner { // 局部内部类
            int num = 10;
            public void methodInner() {
                System.out.println(num); // 10
            }
        }

        Inner inner = new Inner();
        inner.methodInner();
    }

}

局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】

备注：从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略。

原因：

new出来的对象在堆内存当中。
局部变量是跟着方法走的，在栈内存当中。
方法运行结束之后，立刻出栈，局部变量就会立刻消失。
但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。

public class MyOuter {

    public void methodOuter() {
        /**final*/ int num = 10; // 所在方法的局部变量

        class MyInner {
            public void methodInner() {
                System.out.println(num);
            }
        }
    }
}

(3),匿名内部类

如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，
那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。

匿名内部类的定义格式：
接口名称对象名 = new 接口名称() {
// 覆盖重写所有抽象方法
};

对格式“new 接口名称() {...}”进行解析：

new代表创建对象的动作
接口名称就是匿名内部类需要实现哪个接口
{...}这才是匿名内部类的内容

另外还要注意几点问题：

匿名内部类，在【创建对象】的时候，只能使用唯一一次。
如果希望多次创建对象，而且类的内容一样的话，那么就需要使用单独定义的实现类了。
匿名对象，在【调用方法】的时候，只能调用唯一一次。
如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
强调：匿名内部类和匿名对象不是一回事！！！

public interface MyInterface {

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

    void method2();

}

public class MyInterfaceImpl implements MyInterface {
    @Override
    public void method1() {
        System.out.println("实现类覆盖重写了方法！111");
    }

    @Override
    public void method2() {
        System.out.println("实现类覆盖重写了方法！222");
    }
}

测试类：

public class DemoMain {

    public static void main(String[] args) {
//        MyInterface obj = new MyInterfaceImpl();
//        obj.method();

//        MyInterface some = new MyInterface(); // 错误写法！

        // 使用匿名内部类，但不是匿名对象，对象名称就叫objA
        MyInterface objA = new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！111-A");
            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法！222-A");
            }
        };
        objA.method1();
        objA.method2();
        System.out.println("=================");

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

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法！222-B");
            }
        }.method1();
        // 因为匿名对象无法调用第二次方法，所以需要再创建一个匿名内部类的匿名对象
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！111-B");
            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法！222-B");
            }
        }.method2();
    }

}

(4),类作为成员变量类型

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;
    }
}

// 游戏当中的英雄角色类
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;
    }
}
public class DemoMain {

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

        // 创建一个武器对象
        Weapon weapon = new Weapon("AK-47");
        // 为英雄配备武器
        hero.setWeapon(weapon);

        // 年龄为20的盖伦用多兰剑攻击敌方。
        hero.attack();
    }

}

(5),接口作为成员变量的类型

定义一个接口：

public interface Skill {

    public abstract void use(); // 释放技能的抽象方法
    //public abstract 可省略  一定是个抽象方法

}

接口的实现类：

public class SkillImpl implements Skill {
    @Override
    public void use() {
        System.out.println("Biu~biu~biu~");
    }
}

人物类：

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;
    }
}

测试类：

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("Pia~pia~pia~");
//            }
//        };
//        hero.setSkill(skill);

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

        hero.attack();
    }

}

(6),接口作为参数和返回值类型

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;
    }
}

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 202,607评论 5赞 476
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 85,047评论 2赞 379
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 149,496评论 0赞 335
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,405评论 1赞 273
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,400评论 5赞 364
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,479评论 1赞 281
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 37,883评论 3赞 395
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,535评论 0赞 256
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 40,743评论 1赞 295
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,544评论 2赞 319
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,612评论 1赞 329
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,309评论 4赞 318
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 38,881评论 3赞 306
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,891评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,136评论 1赞 259
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 42,783评论 2赞 349
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,316评论 2赞 342

Java继承和多态

1,继承

(1),

(2),在父子的继承的关系当中，若果重命则创建子类对象的时候，有两种方式

(3),变量的使用

(4),在父子类的继承关系当中，创建子类对象访问成员方法的规则

(5),方法覆盖重写的注意事项

(6),父子类构造方法得访问特点

(7),super 关键字的用法三种：

(8),super 关键字用来访问父类内容，this关键字用来访问本类内容，用法三种

2，抽象类

(1),

(2),

(3),抽象类的应用

(4),发红包案例

3,接口

(1),

(2),默认方法

(3),静态方法

(4), 私有方法

(6),常量

(7),接口的使用

(8),

4，多态

(1),定义

(2)，多态的使用

(3),多态的使用

(4),多态的练习

5，final关键字

(1),final关键字代表最终、不可改变的。

6，权限修饰符 day11-code demo02

7，内部类

(1),内部类的定义。

(2),局部内部类

(3),匿名内部类

(4),类作为成员变量类型

(5),接口作为成员变量的类型

(6),接口作为参数和返回值类型

推荐阅读更多精彩内容