抽象和多态

(一)抽象
1.概述:将功能定义抽象,那么该类就是抽象类
2.特点:一个类中可以抽象方法.也可以有非抽象方法
3.格式:public abstract void method();
4.抽象类的子类特点:
子类可以是抽象类,没有任何意义.抽象类不能直接实例化,就不能使用调用方法!
子类是非抽象类,必须要重写父类中的抽象方法,然后去使用子类自己的功能
父类是一个抽象类,如果要创建对象就必须通过子类进行实现.
  父类进行实例化只能间接子类进行实例化.
5.抽象类中的成员的特点:
成员变量:可以是变量,也可以是常量(自定义常量)
成员方法:可以是抽象方法,也可以是非抽象方法
构造方法:一个抽象类中是可以有构造方法的
6.abstract不能和以下的关键字共用
关键字:private,final,static
  private :冲突(要么使用public/protected)
final :冲突
static:无意义!
7.猫狗案例:
package 抽象;
//猫狗案例
public class AbstractDemo {
public static void main(String[] args) {
//创建对象
Animal a = new Cat();

a.setName("折耳猫");
a.setAge(2);
a.setColor("白色");

System.out.println("这是一只"+a.getAge()+"岁的"+a.getColor()+a.getName());

Cat c = (Cat) a;
c.eat();
c.sleep();
c.playGame();
System.out.println("----------");
//创建对象
Animal a2 = new Dog();

a2.setName("哈士奇");
a2.setAge(3);
a2.setColor("黑白");

System.out.println("这是一只"+a2.getAge()+"岁的"+a2.getColor()+a2.getName());

Dog d = (Dog) a2;
d.eat();
d.sleep();
}
}
package 抽象;
//动物抽象类
public abstract class Animal {
//定义成员变量
private String name;
private int age;
private String color;

//无参/有参
public Animal() {
super();
}
public Animal(String name, int age, String color) {
super();
this.name = name;
this.age = age;
this.color = color;
}

//get()/set()
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}

//抽象方法
public abstract void eat();
public abstract void sleep();

}
package 抽象;
//猫类
public class Cat extends Animal {


public Cat() {


}


public Cat(String name, int age, String color) {
super(name, age, color);
}


public void eat(){
System.out.println("猫吃鱼");
}


public void sleep(){
System.out.println("猫趴着睡");
}

public void playGame(){
System.out.println("猫爱玩游戏");
}
}
package 抽象;
//狗类
public class Dog extends Animal {


public Dog() {
}


public Dog(String name, int age, String color) {
super(name, age, color);
}


@Override
public void eat(){
System.out.println("狗狗爱吃骨头");
}


    @Override
public void sleep(){
System.out.println("狗狗躺着睡");
}
}


(二)多态
1.多态:指的是一个事物,在不同时刻状态的一个体现
2.前提条件:
1)必须有继承关系
2)继承一个类的同时,子类中必须有方法重写(使用子类中的方法去覆盖父类中的方法)
3)父类的引用指向子类对象
Fu f = new Zi() ;将f代表的父类引用指向堆内存的子类的对象! 向上转型!
3.多态中的成员访问特点:
package org.westos_多态;
class Fu{
//成员变量
int num = 10;
//构造方法
public Fu(){
System.out.println("fu");
}
//成员方法
public void show(){
System.out.println("show fu");
}
public static void function(){
System.out.println("function Fu");
}
}
class Zi extends Fu{
//成员变量:编译看左,运行看左
int num = 20;
//构造方法
public Zi(){
System.out.println("zi");
}
//非静态成员方法:编译看左,运行看右
public void show(){
System.out.println("show zi");
}
//静态成员方法:编译看左,运行看左
public static void function(){
System.out.println("function Zi");
}
}
//测试类
public class DuoTaiDemo {
public static void main(String[] args) {
Fu f = new Zi();//fu  zi
System.out.println(f.num);//10
f.show();//show Zi
f.function();//function Fu
}
}
4.多态的好处:
提高了代码的维护性(由继承保证)
提高了代码的扩展性(由多态的保证)
5.多态的弊端:
子类只能使用父类的功能:不能使用子类中特有的功能!
要想使用子类具体功能
1)创建子类对象
2)向下转型:将父类的引用强制转换为子类对象
Zi z = (Zi)(f) ;//还原成子类对象
6.猫狗案例以及一个运行异常:
package org.westos_多态;
//动物类
class Animal{
//成员方法
public void eat(){
System.out.println("eat");
}
public void sleep(){
System.out.println("sleep");
}
}
//猫类
class Cat extends Animal{
//成员方法
public void play(){
System.out.println("猫咪爱玩");
}
}
//狗类
class Dog extends Animal{
//成员方法
public void look(){
System.out.println("狗狗很忠诚");
}
}
//测试类
public class DuoTaiDemo2 {
public static void main(String[] args) {
//向上转型
Animal a = new Cat();
a.eat();
// a.play();
System.out.println("------------");
//向下转型,还原成猫
Cat c = (Cat) a;
c.eat();
c.play();
// Dog d = (Dog) a;//java.lang.ClassCastException 运行错误
//向上转型
Animal a1 = new Dog();
a1.eat();
// a1.look();
System.out.println("-----------");
//向下转型,还原成狗
Dog d = (Dog) a1;
d.eat();
d.look();
}
}