java_抽象类_12

• 抽象类的概述
  抽象方法:没有方法体的方法叫做抽象方法。
  抽象类:一般是父类，抽象类中不一定有抽象方法，但是有抽象方法一定是抽象类。
• 抽象类的特点

3.抽象类不能实例化。
因为抽象类不是具体的，但是抽象类有构造方法(构造方法的作用是用于子类访问父类时进行数据初始化)。

	抽象类的实例化其实是靠具体的子类实现的。是多态的方式。
	Animal a = new Cat();

4.抽象的子类

• 抽象类的成员特点与方法特性
  1.抽象类的成员特点：
  成员变量：既可以是变量，也可以是常量。
  构造方法：用于子类访问父类数据的初始化。
  成员方法：既可以是抽象的，也可以是非抽象的。
  2.抽象类的成员方法特性：

A:抽象方法 强制要求子类做的事情。
B:非抽象方法 子类继承的事情，提高代码复用性。

定义一个没有抽象方法的抽象类，目的是为了不让创建对象。

• 抽象的声明格式

1.抽象类的声明格式

abstract class Animal 

2.抽象方法的声明格式。

public abstract void eat();  //抽象方法不能有主体。

//public abstract void eat(){}; 空方法体，会报错。

测试类进行实例化:

class AbstractDemo {
	public static void main(String[] args) {
		//通过多态的方式
		Animal a = new Cat(); //抽象类通过子类重写抽象方法进行实例化。
		a.eat();
	}
}

• 抽象类的成员特点。

abstract class Animal {
	public int num = 10;　　//变量
	public final int num2 = 20;　//常量
	public Animal() {}　//构造方法，用于子类访问父类数据的初始化。
	public Animal(String name,int age){}　//无参构造方法
	public abstract void show();　//抽象方法
	public void method() {　System.out.println("method");　}　//非抽象方法不需要子类重写，子类如果没有就会继承。
}
//具体子类基础抽象类
class Dog extends Animal {　
	public void show() {　System.out.println("show Dog");　}　//重写父类抽象方法
}

class AbstractDemo2 {
	public static void main(String[] args) {
		Animal a = new Dog();
		System.out.println(a.num);
		System.out.println(a.num2);
		a.show();　//重写后的
		a.method();　//继承的
	}
}

• 与abstract不能共存的修饰关键字:private,final,static。

abstract class Fu {
	public abstract void show();
	
	//非法的修饰符组合:
	//private abstract void show();
	
	//非法的修饰符组合
	//final abstract void show();	
	
	//非法的修饰符组合。无意义，通过类名调用一个没有方法体的方法，没有意义。
	//static abstract void show();
	
	public static void method(){	System.out.println("method");	}
}
//具体子类继承抽象父类；重写抽象方法
class Zi extends Fu {
	public void show() {System.out.println("hello");}
}

class AbstractDemo3 {
	public static void main(String[] args) {
		Fu.method();
	}
}

• 抽象类的练习，4个

//定义抽象的动物类
abstract class Animal {
	private String name;
	public Animal() {}
	public Animal(String name) {　this.name = name;　}
	public String getName() {　return name;	}
	public void setName(String name) {　this.name = name;　}
	//定义一个抽象方法
	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 AbstractTest {
	public static void main(String[] args) {
		Animal a = new Dog();
		a.setName("旺财");
		System.out.println(a.getName()+"---"+a.getAge());
		a.eat();
	}
}

2.抽象类老师学员练习

//定义抽象的老师类
abstract class Teacher {
	private String name;
	
	public Teacher() {}
	public Teacher(String name) {
		this.name = name;
	}
	
	public String getName() {　return name;　}
	public void setName(String name) {　this.name = name;　}
	public abstract void teach();
}

class BasicTeacher extends Teacher {
	public BasicTeacher(){}
	public BasicTeacher(String name) {
		super(name);
	}
	public void teach() {　System.out.println("基础班老师讲解JavaSE");　}
}

class WorkTeacher extends Teacher {
	public WorkTeacher(){}
	public WorkTeacher(String name){　super(name);　}
	
	public void teach() {
		System.out.println("就业班老师讲解JavaEE");
	}
}

class AbstractTest2 {
	public static void main(String[] args) {
		Teacher t = new BasicTeacher();　//无参构造
		t.setName("刘意");
		System.out.println(t.getName()+"---");
		t.teach();
		
		t = new BasicTeacher("刘意",30);
		System.out.println(t.getName()+"---");
		t.teach();
		
		//就业班老师
		t = new WorkTeacher();
		t.setName("林青霞");
		System.out.println(t.getName()+"---");
		t.teach();
		
		t = new WorkTeacher("林青霞",27);
		System.out.println(t.getName()+"---");
		t.teach();
	}
}



//定义抽象学员类
abstract class Student {
	private int age;
	public Student() {}
	public Student(int age){　this.age = age;　}	
	
	public int getAge() {　return age;　}
	public void setAge(int age) {　this.age = age;　}
	
	public abstract void study();
	public void eat() {　System.out.println("学习累了,就该吃饭");　}
}

class BasicStudent extends Student {
	public BasicStudent() {}
	public BasicStudent(int age) {　super(age);　}
	
	public void study() {　System.out.println("基础班学员学习的是JavaSE");　}
}

class WorkStudent extends Student {
	public WorkStudent() {}
	public WorkStudent(int age) {　super(name,age,grand);　}
	
	public void study() {　System.out.println("就业班学员学习的是JavaEE");　}
}

class AbstractTest3 {
	public static void main(String[] args) {
		//按照多态的方式测试
		Student s = new BasicStudent();
		s.setAge(27);
		System.out.println(s.getAge());
		s.study();
		s.eat();
		
		s = new BasicStudent(48);
		System.out.println(s.getAge()+"---");
		s.study();
		s.eat();
	}
}




//定义员工类
abstract class Employee {
	//姓名、工号以及工资
	private String name;
	private String id;
	private int salary;
	
	public Employee() {}
	
	public Employee(String name,String id,int salary) {
		this.name = name;
		this.id = id;
		this.salary = salary;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public String getId() {
		return id;
	}
	
	public void setId(String id) {
		this.id = id;
	}
	
	public int getSalary() {
		return salary;
	}
	
	public void setSalary(int salary) {
		this.salary = salary;
	}
	
	//工作
	public abstract void work();
}

//普通员工类
class Programmer extends Employee {
	public Programmer(){}
	
	public Programmer(String name,String id,int salary) {
		super(name,id,salary);
	}
	
	public void work() {
		System.out.println("按照需求写代码");
	}
}

//经理类
class Manager extends Employee {
	//奖金
	private int money; //bonus 奖金

	public Manager(){}
	
	public Manager(String name,String id,int salary,int money) {
		super(name,id,salary);
		this.money = money;
	}
	
	public void work() {
		System.out.println("跟客户谈需求");
	}
	
	public int getMoney() {
		return money;
	}
	
	public void setMoney(int money) {
		this.money = money;
	}
}

class AbstractTest4 {
	public static void main(String[] args) {
		//测试普通员工
		Employee emp = new Programmer();
		emp.setName("林青霞");
		emp.setId("czbk001");
		emp.setSalary(18000);
		System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
		emp.work();
		System.out.println("-------------");
		emp = new Programmer("林青霞","czbk001",18000);
		System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
		emp.work();
		System.out.println("-------------");
		
		/*
		emp = new Manager();
		emp.setName("刘意");
		emp.setId("czbk002");
		emp.setSalary(8000);
		emp.setMoney(2000);
		*/
		//由于子类有特有的内容，所以我们用子类来测试
		Manager m = new Manager();
		m.setName("刘意");
		m.setId("czbk002");
		m.setSalary(8000);
		m.setMoney(2000);
		System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
		m.work();
		System.out.println("-------------");
		
		//通过构造方法赋值
		m = new Manager("刘意","czbk002",8000,2000);
		System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
		m.work();
	}
}