1.多态：对象在不同时刻表现出来的不同状态。
针对引用类型：
编译期间状态，
运行期间状态，
前提：
A：要有继承关系
B：要有方法重写
C：父类引用或父接口指向子类对象
例题：class Fu{
public void show(){
System.out.println("A");
}
}
class Zi extends Fu{
public void show(){
System.out.println("B");
}
}
class Test{
public static void main(String[] args){
//多态
Fu fu = new Zi();
}
}
2.多态的成员特点：方法有重写，变量没有。
A：成员变量：
编译看左边，运行看左边
B：成员方法：
编译看左边，运行看右边
例题：class Fu{
int num = 10;
public void show(){
System.out.println("A");
}
}
class Zi extends Fu{
int num = 20;
public void method(){
System.out.println("C");
}
public void show(){
System.out.println("B");
}
}
class Test{
public static void main(String[] args){
//多态
Fu fu = new Zi();
System.out.println(num);//10
fu.show();//B
fu.method();//报错，编译时父类没有method方法
}
}
3.多台弊端：父类引用不能使用子类特有功能
关于转换：
基本数据类型：
a.隐式转换（小--->大） b.强制转换（大--->小）
引用数据类型：
a.向上转型（小--->大） b.向下转型（大--->小）
例题：class Fu{
int num = 10;
public void show(){
System.out.println("A");
}
}
class Zi extends Fu{
int num = 20;
public void method(){
System.out.println("C");
}
public void show(){
System.out.println("B");
}
}
class Test{
public static void main(String[] args){
//多态
Fu fu = new Zi();//向上转型
Zi z = (Zi)fu;//向下转型
System.out.println(num);//10
}
}
4.异常：java.lang.ClassCastException 类型转换异常
例题：class Animal
{
public void show(){
System.out.println();
}
}
class Cat extends Animal
{
public void method(){
System.out.println("cat method");
}
public void show(){
System.out.println("cat show ");
}
}
class Dog extends Animal
{
public void show(){
System.out.println("dog show");
}
public void method(){
System.out.println("dog method");
}
}
class DuoTaiDemo
{
public static void main(String[] args){
Animal a = new Cat();//向上转型
a.show();
a = new Dog();//重新赋值
a.show();
Dog d = (Dog)a;//向下转型
d.show();
Cat c = (Cat)a;//ClassCastExceprion:类型转换异常
c.show();
}
}
5.多态的好处： 为了提高代码的复用性
例题：class Animal{
public void show(){
System.out.println("Animal show");
}
public void eat(){
System.out.println("Animal eat");
}
}
class Dog extends Animal{
public void show(){
System.out.println("Dog show");
}
public void eat(){
System.out.println("Dog eat 骨头");
}
}
class Cat extends Animal{
public void show(){
System.out.println("Cat show");
}
public void eat(){
System.out.println("Cat eat 鱼");
}
}
class wolf extends Animal{
public void show(){
System.out.println("wolf show");
}
public void eat(){
System.out.println("wolf eat 肉");
}
}
class AnimalTool{
private AnimalTool(){}
public static void printAnimal(Animal a){
a.eat();
a.show();
}
}
class HaoChu{
public static void main(String[] args){
Dog d = new Dog();
AnimalTool.printAnimal(d);
}
}
6.抽象：abstract class Animal{
public abstract void eat();
}
针对没有方法体的方法，java提供了一种表示形式：抽象方法。
抽象方法就是没有方法体的方法
抽象类不能创建对象，不能实例化
抽象类的由来：从很多对象中中抽取相同的方法声明，定义在一个新的类中，没有方法体的方法被成为抽象方法，存储抽象方法的类就
是抽象类
7.抽象类的特点：
A：抽象方法和抽象类用关键字 abstract 表示
B：有抽象方法的类一定是抽象类或接口
抽象类中一定有抽象方法
C：抽象类不能被实例化
如何实例化？通过子类对象实例化
D：如果一个类继承抽象，那么这个类要么本身也是抽象类，要么子类重写父类的抽象方法
8.在继承中为什么选择父类为抽象类呢？
强制要求子类必须完成某些功能
9.抽象类的成员特点：
A：成员变量:既有常量，也可以有变量
B：构造方法：有构造方法
不能实例化，要构造方法何用呢？
用于子类访问父类数据钱对父类数据进行初始化
C：成员方法：可以有抽象方法，也可以有非抽象方法，非抽象方法是为了提高代码的复用性。抽象方法是为了强制子类实现某些功能
10.接口：只有抽象方法的抽象类，用interface表示
把抽象类改写为：
interface Animal{
public abstract void eat();
}
接口怎么用？必须要有具体的类来实现（implements）
格式：class 类名 implements 接口名{
}
例题：class Cat implements Animal{
public void eat(){
System.out.println("");
}
}
11.接口多态：
Animal a = new Cat();
a.eat();
12.接口特点：
A：接口不能被实例化
B：接口中的方法要么被子类重写，要么子类也是抽象类
13.接口的成员特点：
成员变量：接口中只有常量，因为接口中的成员变量有默认的修饰符 public static final
推荐：永远手动写出修饰符
构造方法：接口中没有构造方法，接口不需要对数据初始化，因为接口被静态修饰，只有常量，不需要初始化
成员方法：接口中的方法都是抽象的，接口中的成员方法有默认的修饰符 public abstract 永远手动给出修饰符
14.类与接口的关系：
实现关系，可以单实现也可以多实现，并且可以在继承一个类的同时实现多个接口
类与类的关系：
继承关系，而且只能单继承，但可以多层继承
类与接口：
继承关系，可以单继承，也可以多继承
15*****面试常考
A：成员特点：
抽象类：
成员变量：可以是变量，也可以是常量
构造方法：有构造方法
成员方法：可以是抽象方法也可以是非抽象方法
接口：
成员变量：只能是常量 默认修饰符是 public static final
成员方法：只能是抽象方法 默认修饰符 public abstract
B：关系特点：
类与类：继承关系，只能单继承，可以多层继承
类与接口：实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口。
类与接口：继承关系，可以单继承，也可以多继承。
C：设计理念的区别：
抽象类被继承，这个类中是继承体系的共性内容
体现：is a 关系
接口被实现，这个接口中定义的是整个体系的扩展内容
体现：like a 关系 |
|
收藏
淘帖
踩
