标签：共存 面向对象 数据 规则 角度 get 抽象 phi 常量
a：要有继承关系
b：要有方法重写
c：要有父类引用指向子类对象
成员变量：编译看左边（父类），运行看左边（父类）
多态中的成员访问特点之成员方法：
成员方法：编译看左边（父类），运行看右边（子类）
多态中的成员访问特点之静态成员方法：
静态方法：
编译看左边（父类），运行看左边（父类）
（静态和类相关，算不上重写，所以访问还是左边的）
只有非静态的成员方法，编译看左边，运行看右边
a：提高了代码的维护性（继承保证）
b：提高了代码的扩展性（由多态保证）
不能使用子类特有属性和行为
多态中的题目分析题：
class A { public void show() { how2(); } public void show2() { System.out.println("我"); } } class B extends A { public void show2() { System.out.println("爱"); } } class C extends B { public void show(){ super.show(); } public void show2() { System.out.println("你"); } } public class TestDuoTai(){ public static void main(String[] args){ A a = new B(); a.show(); B b = new C(); b.show(); } }
抽象就是看不懂的
abstract class 类名 {}
public abstract void eat（）；
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态
要么是抽象类
要么重写抽象类中的所有抽象方法
abstract不能修饰成员变量
被abstract修饰的方法没有方法体
被static崔氏的可以用类名.调用,但是类名.调用抽象方法是没有意义的
被abstract修饰的方法强制子类重写
被final修饰的不然让子类重写,所以他俩是矛盾的
被abstract修饰的是为了让子类看到并强制重写
被private修饰的不让子类访问,所以他俩是矛盾的
从狭义的角度讲就是指java中的interface
从广义的角度讲就是对外提供规则的都是接口
interface 接口名 {}
class 类名 implements 接口名 {}
可以按照多态的方式实例化
a：可以是抽象类。但是意义不大
b：可以是具体类。要重写接口中的所有抽象方法
只能是常量，并且是静态的并公共的
默认修饰符：public static final（最好自己手动给出）
构造方法：接口没有构造方法
只能是抽象方法
默认修饰符：public abstract（最好自己手动给出）
继承关系，只能单继承，可以多层继承
实现关系，可以单实现，也可以多实现
并且还可以在继承一个类的同时实现多个接口
继承关系，可以单继承，也可以多继承
成员变量：可以变了，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象
成员变量：只可以常量
成员方法：只可以抽象
继承，单继承
实现，单实现，多实现
继承，单继承，多继承
抽象类：被继承体现的是：“is a”的关系。抽象类中定义的是该继承体系的共性功能。
接口：被实现体现的是：“like a”的关系。接口中定义的是该继承体系的扩展功能。
class Test_Animal { public static void main(String[] args){ Cat c = new Cat("加菲",8); c.eat(); c.sleep(); JumpCat js = new JumpCat("跳高猫",9); jc.eat(); jc.sleep(); jc.jump(); } abstract class Animal { private String name; <!-- 姓名 --> private int age; <!-- 年龄 --> public Animal(){} <!-- 空参构造 --> public Animal(String name,int age){ <!-- 有参构造 --> this.name = name; this.age = age; } public void setName(String name){ <!-- 设置姓名 --> this.name = name; } public String getName(){ <!-- 获取姓名 --> return name; } public void setAge(int age){ <!-- 设置年龄 --> this.age = age; } public String getAge(){ <!-- 获取年龄 --> return age; } public abstract void eat(); <!-- 吃饭 --> public abstract void sleep(); <!-- 睡觉 --> } interface Jumping { <!-- 跳高接口 --> public void jump(){}; } class Cat extends Animal { public Cat(){} <!-- 空参构造 --> public Cat(String name,int age){ <!-- 有参构造 --> super(name,age); } public void eat(){ System.out.println("猫吃鱼"); } public void sleep(){ System.out.println("躺着睡"); } } class JumpCat extends Cat implements Jumping { public void jump(){ public JumpCat(){} <!-- 空参构造 --> public JumpCat(String name,int age){ <!-- 有参构造 --> super(name,age); } System.out.println("猫跳高"); } }
2019-05-17 Java学习日记之面向对象_多态&抽象类&接口
标签：共存 面向对象 数据 规则 角度 get 抽象 phi 常量
原文地址：https://www.cnblogs.com/clqbolg/p/10884445.html
