Java学习笔记五（多态）

1 抽象类

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

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

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] default void fn() { …} // 带方法体的公开方法，可以被实现类（继承，调用，重写）。如果子类实现多个接口有相同默认方法，子类必须重写默认方法。父类与接口有相同默认方法，优先使用父类默认方法。

(7) 接口静态方法(jdk8)：[public] static void fn() { …} // 带方法体的静态方法，只能接口名调用。

(8) 接口私有方法(jdk9)：private void 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();   返回yyyreturn "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);  // 输出：子类1outFn(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);  // 输出：子类1outFn(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);  // 输出：子类1outFn(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);          // 输出：你谁啊？}
}