【JAVA】多态与抽象类

多态中父类引用指向子类对象，且只有父类引用能指向父类自己，函数被重载与重写。在用依赖和关联时，随着客户需求的不断增加，我们的代码就显得臃肿。为了减少重复性的工作，我们就需要创建一个父类。让其他类继承它，让代码的复用率、效率和拓展性增加。

抽象类，顾名思义，它不是一个具体的类。抽象类和一般类没有太大差异，该怎么描述事物就怎么描述，只不过出现了一些看不懂的东西。而这些不确定的部分，也是该事物的功能，需要被明确。又因为其无法被定义出主体，只能通过抽象方法来体现。抽象类里头可以不定义抽象方法，主要是为了不让该类被new创建和实例化对象，因为抽象类是不完整的，且调用抽象方法是无意义的；抽象方法必须包含在抽象类中。从继承方面来讲，如果子类只包含了部分抽象方法，那该子类还是一个抽象类。

abstract 关键字，和哪些关键字不能共存。
final：被final修饰的类不能有子类（不能被继承）。而被abstract修饰的类一定是一个父类（一定要被继承）。
private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。
而抽象方法出现的就是需要被复写。
static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。
可是抽象方法运行没意义。

多态例题

public class Chinese extends Person{

	public Chinese(String name) {
		super(name);
	}
	public void speak() {
		System.out.println("中文");
	}
}

public class College extends Student{
	private int subject;

	public College() {
		super("张三",23234,'M');
	}

	public void study() {
		super.study();
		//只能在子类里面调用父类的方法，
		//在外部无继承的类里不能被调到。
		System.out.println("学习高数！");
		System.out.println("学习外语！");
		System.out.println("学习物理！");
	}

	public int getSubject() {
		return subject;
	}

	public void setSubject(int subject) {
		this.subject = subject;
	}
}

public class Student {
	private String name;
	private int id;
	private char sex;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public char getSex() {
		return sex;
	}

	public void setSex(char sex) {
		if(sex=='M'||sex=='F') {
		this.sex = sex;
		}		
	}
	
//	public void setProp(String name,int id,char sex) {
//			this.setName(name);
//			this.setId(id);
//			this.setSex(sex);
//		}
		
	public void study() {
		System.out.println("学习！");
	}

	
	public Student(String name,int id,char sex) {
			this.setName(name);
			this.setId(id);
			this.setSex(sex);
		}
}

任务一

public class Test1 {
	public static void main(String[] args) {
		Student s=new Student("张三",232234,'M');
		College c=new College();
//		s.study();
//		c.study();
//		c.study();
		s=c;//多态
		s.study();
//在子类外部，只能调用子类里面继承父类的属性，重写除外。
		s.setName("");
		s.setId(232234);
		s.setSex('M');
		c.setSubject(42134);
		
	}
}

任务二

public class Test_polymorphic {
	public static void main(String[] args) {
		Person p = new Chinese("张三");
		Coke c = new Coke();
		p.eat(c);
		Duck d = new Duck();
		p.eat(d);
		Fish f = new Fish();
		p.eat(f);

		// 调用抽象类之后，我们就不能再重新创建该类。
		// Food aa=new Food();
		// p.eat(aa);
	}
}

任务三

public class StudentTest {
	public static void main(String[] args) {
//		Student s=new Student();
//		当有了有参构造函数，
//		编译器就不会分配默认构造函数了。
		
		Student s=new Student("张三",232234,'M');
//		调用有参构造函数
//		s.setName("张三");
//		s.setCode(232234);
//		s.setSex('M');
	}
}

抽象类、抽象方法例题

public class Coke extends Food{
//	private String name = "芦花鸡";
//
//	public String getName() {
//		return name;
//	}
//
//	public void setName(String name) {
//		this.name = name;
//	}
	public Coke() {
		super.setName("芦花鸡");
	}
}

public class Duck extends Food {
	public Duck() {
		super.setName("芦花鸭");
	}

}

public class Fish extends Food {
	public Fish() {
		super.setName("甲鱼");
	}
}

public abstract /* 抽象类 */class Food {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

public abstract class Person {
	private String name;

	public Person(String name) {
		super();
		this.name = name;
	}

	// //依赖
	// public void eat(Coke c) {
	// System.out.println(this.name+"吃"+c.getName());
	// }
	//
	// public void eat(Duck c) {
	// System.out.println(this.name+"吃"+c.getName());
	// }

	public void eat(Food c) {
		System.out.println(this.name + "吃" + c.getName());
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;

	// 抽象方法：public void speak();也可写为public abstract void speak();
	// 没有大括号的方法为抽象方法
	}
}