Java学习笔记五（多态）

1 抽象类

(1) 定义抽象类 ：public abstractclass 类名 {...}

注释：抽象类可以没有抽象方法，有抽象方法的类一定是抽象类

public abstract class 类名 {
    public abstract void 方法();
}

(2) 实现抽象类： public 子类 extends抽象类{ ... }

注释：抽象类只能单继承，子类必须实现父类抽象方法，或者子类定义为抽象类

2 接口

(1) 定义接口： public interface接口名 {...}

(2) 接口变量： public static final 类型 变量名 = 值; //默认并且只能是public static final

(3) 接口方法： public abstract 返回值类型 方法名(); //默认并且只能是public abstract

(4) 实现接口： public class 类 extends 父类 implements****接口1,接口2 {... } // 类可实现多个接口，必须先写继承后写实现

(5) 继承接口： public interface 接口 extends****接口, 接口{...} // 接口用extends关键字继承多个接口

注释：被继承或实现的多个接口内（不可有方法名参数相同，返回值不同的方法，子类会报错）

(6) 接口默认方法(jkd8) ：public defaultvoid fn() { ...} // 带方法体的公开方法，可以被实现类（继承，调用，重写）。如果子类实现多个接口有相同默认方法，子类必须重写默认方法。父类与接口有相同默认方法，优先使用父类默认方法。

(7) 接口静态方法(jdk8)： public staticvoid fn() { ...} // 带方法体的静态方法，只能接口名调用。

(8) 接口私有方法(jdk9)： privatevoid fn(){...} // 带方法体，接口私有方法或默认方法可调用。

3 枚举类

(1) 无参枚举类： //私有构造器可省略

public enum 枚举名 {
  A,
  B;
  [private 枚举名() {...}]
}

(2) 有参枚举类：

public eunm 枚举名 {
  A(1, "zhangsan"),
  B(2, "lisi");

  private int age;
  private String name;

  private 枚举名(int age, String name) {
    this.age = age;
    this.name = name;
  }

  public int getAge() {
    return age;
  }
}

获取所有枚举对象：枚举名.values();

(3) 抽象枚举

public enum 枚举名 {
  A() {                         // 枚举名.A.toString()   输出"A"
    public String test() {
      return "xxx";
    }
  },
  B() {
    public String test() {      // 实现抽象方法, 枚举名.B.test();   返回yyy
      return "yyy";
    }
  };

  [private 枚举名() {...}]      // 默认私有构造器

  public abstract String test();  //抽象方法

}

4 多态

多态分为：1对象多态，2行为多态

4.1 对象多态

对象多态指：一个父类或接口，有多个实现类。不同的子类执行有不同的效果。

4.1.1 父类多态

// 父类
public class A {
    public String out() {
        return "父";
    }
}

// 子类1
public class B1 extends A {
    public String out() {
        return "子类1";
    }
}

// 子类2
public class B1 extends A {
    public String out() {
        return "子类2";
    }
}

测试： 同一个函数（例outFn）调用不同对象（参数类.out()）得到不同的结果

public class Test {
    public static void main(String[] args) {
        A a = new A();
        A b1 = new B1();
        A b2 = new B2();

        outFn(a);   // 输出：父
        outFn(b1);  // 输出：子类1
        outFn(b2);  // 输出：子类2
    }

    // 输出类的返回值；
    public static void outFn(A a) {
        System.out.print(a.out());
    }
}

4.1.2 抽象类多态

// 父抽象类
public abstract class A {
    public abstract String out();
}

// 子类1
public class B1 extends A {
    public String out() {
        return "子类1";
    }
}

// 子类2
public class B1 extends A {
    public String out() {
        return "子类2";
    }
}

测试： 同一个函数（例outFn）调用不同的实现类（参数类.out()）得到不同的结果

public class Test {
    public static void main(String[] args) {
        A b1 = new B1();
        A b2 = new B2();

        outFn(b1);  // 输出：子类1
        outFn(b2);  // 输出：子类2
    }

    // 输出类的返回值；
    public static void outFn(A a) {
        System.out.print(a.out());
    }
}

4.1.3 接口多态

// 父接口
public interface A {
    public abstract String out();
}

// 子类1
public class B1 implements A {
    public String out() {
        return "子类1";
    }
}

// 子类2
public class B1 implements A {
    public String out() {
        return "子类2";
    }
}

测试： 同一个函数（例outFn）调用不同的接口实现类（参数类.out()）得到不同的结果

public class Test {
    public static void main(String[] args) {
        A b1 = new B1();
        A b2 = new B2();

        outFn(b1);  // 输出：子类1
        outFn(b2);  // 输出：子类2
    }

    // 输出类的返回值；
    public static void outFn(A a) {
        System.out.print(a.out());
    }
}

4.2 行为多态

行为多态指：一个类，有多个同名方法（方法重载）。调用同一个方法，根据参数不同，会得到不同的结果。

public class A {
    public String out(String name) {
        return "你好" + name;
    }
    public String out(String name, int age) {
        return "你好" + age + "岁的" + name;
    }
    public String out(int age) {
        return "你谁啊？";
    }
}

测试： 同一个名字函数（例out）参数不同得到不同的结果

public class Test {
    public static void main(String[] args) {
        A a = new A();

        a.out("张三");      // 输出：你好张三
        a.out("张三", 18);  // 输出：你好18岁的张三
        a.out(30);          // 输出：你谁啊？
    }
}