java练习-抽象类06

1 抽象类概念

抽象类的概述:
	动物不应该定义为具体的东西,而且动物中的吃,睡等也不应该是具体的。
	我们把一个不是具体的功能称为抽象的功能,而一个类中如果有抽象的功能,该类必须是抽象类。
	
抽象类的特点:
	A:抽象类和抽象方法必须用abstract关键字修饰
	B:抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类
	C:抽象类不能实例化
		因为它不是具体的。
		抽象类有构造方法,但是不能实例化?构造方法的作用是什么呢?
		用于子类访问父类数据的初始化
	D:抽象的子类
		a:如果不想重写抽象方法,该子类是一个抽象类。
		b:重写所有的抽象方法,这个时候子类是一个具体的类。
		
	抽象类的实例化其实是靠具体的子类实现的。是多态的方式。
		Animal a = new Cat();

---

2 抽象类练习猫狗案例

猫狗案例
	具体事物:猫,狗
	共性:姓名,年龄,吃饭

分析:从具体到抽象
	猫:
		成员变量:姓名,年龄
		构造方法:无参,带参
		成员方法:吃饭(猫吃鱼)
		
	狗:
		成员变量:姓名,年龄
		构造方法:无参,带参
		成员方法:吃饭(狗吃肉)
		
	因为有共性的内容,所以就提取了一个父类。动物。
	但是又由于吃饭的内容不一样,所以吃饭的方法是抽象的,
	而方法是抽象的类,类就必须定义为抽象类。
	
	抽象动物类:
		成员变量:姓名,年龄
		构造方法:无参,带参
		成员方法:吃饭();

实现:从抽象到具体
	动物类:
		成员变量:姓名,年龄
		构造方法:无参,带参
		成员方法:吃饭();
		
	狗类:
		继承自动物类
		重写吃饭();
		
	猫类:
		继承自动物类
		重写吃饭();

package cn.plsite.day04.demo06;

abstract public class Animal {
    String name;
    int age;
    public abstract void eat();

    public Animal(){
        System.out.println("animal无参数构造");
    }
    public Animal(String name,int age){
        System.out.println("animal有参数构造");//少东西
    }

}


package cn.plsite.day04.demo06;

public class Cat extends Animal {

//public  Cat(){
//    System.out.println("cat无参数构造方法");
//}
//public Cat(int age,String name){
//    System.out.println("cat有参数构造方法");
//
//}
public void eat(){
    System.out.println("猫吃鱼");
}

}


package cn.plsite.day04.demo06;
//使用普通子类实现抽象方法
class Dog extends Animal{
//    public Dog(){
//        System.out.println("dog无参数构造方法");
//    }
//    public Dog(int age,String name){
//        System.out.println("DOG有参数构造方法");
//    }
    public void eat(){
        System.out.println("狗吃肉");
    }
}

package cn.plsite.day04.demo06;

 public class ImplementAnimal{
     public static void main(String[] args) {
         Cat cat = new Cat();
         cat.eat();

         new Dog().eat();
//         Dog dog = new Dog();
//         dog.eat();
     }
}

答案：

abstract class Animal {
	//姓名
	private String name;
	//年龄
	private int age;
	
	public Animal() {}
	
	public Animal(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	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 abstract void eat();
}

//定义具体的狗类
class Dog extends Animal {
	public Dog() {}
	
	public Dog(String name,int age) {
		super(name,age);
	}
	
	public void eat() {
		System.out.println("狗吃肉");
	}
}

//定义具体的猫类
class Cat extends Animal {
	public Cat() {}
	
	public Cat(String name,int age) {
		super(name,age);
	}
	
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

//测试类
class AbstractTest {
	public static void main(String[] args) {
		//测试狗类
		//具体类用法
		//方式1:
		Dog d = new Dog();
		d.setName("旺财");
		d.setAge(3);
		System.out.println(d.getName()+"---"+d.getAge());
		d.eat();
		//方式2:
		Dog d2 = new Dog("旺财",3);
		System.out.println(d2.getName()+"---"+d2.getAge());
		d2.eat();
		System.out.println("---------------------------");
		
		Animal a = new Dog();
		a.setName("旺财");
		a.setAge(3);
		System.out.println(a.getName()+"---"+a.getAge());
		a.eat();
		
		Animal a2 = new Dog("旺财",3);
		System.out.println(a2.getName()+"---"+a2.getAge());
		a2.eat();
		
		//练习:测试猫类
	}
}

注意：练习中左右对象关系

1.一个类如果没有抽象方法,可不可以定义为抽象类?如果可以,有什么意义?
	A:可以。
	B:不让其创建对象。

2.abstract不能和哪些关键字共存?
	private	冲突
	final		冲突	
	static	无意义