Java的多态，抽象类是什么

Day8Java

一、has-a：xx有xx

士兵有一把枪

枪可以发射

士兵可以射击

soldier：

public class Soldier{
    String name;
    Gun gun;
    public void setShoot(){
        System.out.println("士兵射击");
        gun.shoot();
    }
}

gun：

public class Gun {
    public void shoot(){
        System.out.println("枪射击");
    }
}

运行：

public static void main(String[] args) {
        Soldier soldier=new Soldier();
        Gun ak47=new Gun();
        soldier.gun=ak47;
        soldier.name="李云龙";
        soldier.setShoot();
    }

二、抽象类

1.没有足够信息描绘一个对象

2.不能实例化对象，但其他非抽象功能依然存在

3.一个类包含抽象方法，那么该类就必须定义成抽象类

特点：

1.抽象类不能被实例化

2.抽象类只能用作父类，继承抽象类的非抽象类必须实现其中的所有抽象方法，而已实现方法的参数，返回值，要和抽象类的方法一样，否则也必须声明为抽象类

抽象方法：一种只有声明没有具体的实现的方法，必须用abstract修饰

如何声明：

[访问权限] abstract class 类名 {成员列表}

public abstract class Shapes{public abstract void draw();}

为什么要用抽象类抽象方法：

当子类里面都有同一种功能但这种功能稍有区别的时候就需要父类里面有抽象方法，比如猫和人都可以吃东西，但是人坐着吃猫趴着吃，这时候就需要父类里有一个吃的抽象方法，不需要定义它的功能，等到猫和人两个子类里具体实现两种吃法的时候在子类里面再方法重写一遍吃的方法

注意：静态方法不可以声明在抽象类里，静态方法不可以被重写

三、多态

同一种事物，在不同时刻表现不同状态

二者存在直接或者简介的继承关系时，父类引用指向子类引用形成多态

好处：提高代码扩展性

什么时候用：同一个事件发生在不同的对象上会产生不同的结果。

比方说按下 F1 键这个动作，如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；如果当前在 Word 下弹出的就是 Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。

Animals：

public abstract class Animals {//抽象类
    public abstract void eat();//抽象方法
}

Cat：

public class Cat extends Animals{
    public void eat(){
        System.out.println("喂猫吃");
    }
}

Dog：

public class Dog extends Animals{
    public void eat(){
        System.out.println("喂狗吃");
    }
}

Person+运行：

不用多态：

public class Person {

    public static void anmialsEat(Cat cat){
        cat.eat();
    }
    public static void anmialsEat(Dog dog){
        dog.eat();
    }
    public static void main(String[] args) {
        Dog dog1=new Dog();
        Cat cat1=new Cat();
        anmialsEat(cat1);
        anmialsEat(dog1);
    }
}

用多态：只用一个父类可以表示不同的子类对象

public class Person {

    public static void anmialsEat(Animals animals){
        animals.eat();
    }
    public static void main(String[] args) {
        //编译看左边，运行看右边，如果子类没有重写，调用子类中的父类方法，总之都是调用子类中的方法
        Animals cat=new Cat();//让cat有Animals和Cat共同功能
        Animals dog=new Dog();//让dog有Animals和Dog共同功能
        anmialsEat(cat);//猫吃
        anmialsEat(dog);//狗吃
    }
}

可以看到用多态后只需要Person中有一个方法即可

多态环境下对静态成员方法的调用：

class Animal{
	static void show() {
		System.out.println(“Animal");
	}
}

class Cat extends Animal {
	static void show() {
		System.out.println(“Cat");
	}
}

Animal x = new Cat()
x.show() //调用的是Animals类中的静态成员方法。

总结：编译运行都看左边

对成员变量的调用：

class Animal{
	int num = 3;
}
class Cat extends Animal {
	int num = 4;
}
Animal x = new Cat()
x.num; //3   调用的是Animals类中的成员变量。

总结：编译和运行都看等号左边

注意：变量不存在被子类覆盖这一说法，只有方法存在覆盖

向下转型：

class Animal{
	void eat(){ }
}
class Cat extendsAnimal{
	void look() {
		System.out.println("看家");
	}
}
Animal x=new Cat()
x.look();//编译报错,Animal类型中没有look方法
Cat m=(Cat)x; //需要向下转型,转为Cat类型
m.eat() ;
m.look();//子父类中的方法都可以使用

作用：为了使用子类中的特有方法

if(animal instanceof Dog){//如果传入的animals属于Dog类型就执行
	Dog dog = (Dog)animal;//向下转型
	dog.lookhome;//调用dog里的方法(Animals没有)
}

final关键字：

被final修饰的

1.类不饿能被定义为抽象类或接口，不可被继承

2.方法在子类里不可以重写

3.参数在方法中不可被修改

4.属性定义时就必须直接赋值或者在构造方法中赋值，并且后期都无法修改

四、接口

从本质上讲，接口时一种特殊的抽象类，这种抽象类包含抽象方法

public interface MyInterface {
	int num = 10;//所有属性默认认为：public static final
	public void foo()；//抽象方法时：public abstr
	public static void test(){ }//jdk8之后加入静态方法，接口可直接调用
	public default void test1(){}//jdk8之后添加默认方法，通过子类调用，default当别的方法都不执行的时候执行此方法
}

格式：

声明：

[访问修饰符] interface 接口名称 [extends 其他的接口1,接口2，接口3…]{

​ //声明常量 抽象方法 静态方法 默认方法

}

接口的使用：类使用implements关键字实现接口。implements关键字放在class声明后面。

[访问修饰符] class 类名 implements 接口名1，2，3…{}

结合继承：

[访问修饰符] class 类名 extends 父类名 implements 接口1 接口2…{}

接口的特性

1.接口是隐式抽象的，主要用来定义功能.

2.接口中可以定义静态常量,抽象方法,静态方法,默认方法.

3.一个接口能继承其它多个接口.

4.接口不能实例化对象.

5.接口是要被类实现,一个接口可以被多个实现

6.当类实现接口的时候，类要实现接口中所有的抽象方法,否则，该类必须

声明为抽象的类.

7.接口与实现类之间存在多态性