物件導向-抽象類

ZHOU_VIP發表於2017-05-06

抽象類的特點：


/*
	抽象類的概述：
		動物不應該定義為具體的東西，而且動物中的吃，睡等也不應該是具體的。
		我們把一個不是具體的功能稱為抽象的功能，而一個類中如果有抽象的功能，該類必須是抽象類。
		
	抽象類的特點：
		A:抽象類和抽象方法必須用abstract關鍵字修飾
		B:抽象類中不一定有抽象方法,但是有抽象方法的類必須定義為抽象類
		C:抽象類不能例項化
			因為它不是具體的。
			抽象類有構造方法，但是不能例項化?構造方法的作用是什麼呢?
			用於子類訪問父類資料的初始化
		D:抽象的子類
			a:如果不想重寫抽象方法，該子類是一個抽象類。
			b:重寫所有的抽象方法，這個時候子類是一個具體的類。
			
		抽象類的例項化其實是靠具體的子類實現的。是多型的方式。
			Animal a = new Cat();
*/

//abstract class Animal //抽象類的宣告格式
abstract class Animal {
	//抽象方法
	//public abstract void eat(){} //空方法體,這個會報錯。抽象方法不能有主體
	public abstract void eat();
	
	//抽象類有構造方法，但是不能例項化
	public Animal(){}
}

//要麼子類是抽象類
abstract class Dog extends Animal {}

//要麼子類是具體類，重寫抽象方法
class Cat extends Animal {
	public void eat() {
		System.out.println("貓吃魚");
	}
}

class AbstractDemo {
	public static void main(String[] args) {
		//建立物件
		//Animal a = new Animal();//Animal是抽象的; 無法例項化，可以通過子類例項化
		
		//通過多型的方式，多型主要不是在具體類之間使用，而是在抽象類之間使用
		Animal a = new Cat();
		a.eat();
	}
}

抽象類的成員特點：


/*
	抽象類的成員特點：
		成員變數：既可以是變數，也可以是常量。
		構造方法：有。
					用於子類訪問父類資料的初始化。
		成員方法：既可以是抽象的，也可以是非抽象的。
		
	抽象類的成員方法特性：
		A:抽象方法   強制要求子類做的事情。
		B:非抽象方法 子類繼承的事情，提高程式碼複用性。
*/
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();
		a.num = 100;
		System.out.println(a.num);//100
		
		a.num2 = 200;
		System.out.println(a.num2);//報錯，public final int num2 = 20;是常量
		System.out.println("--------------");
		
		a.show();  //show Dog
		a.method();//method
	}
	
}

抽象類練習貓狗案例：


/*
	貓狗案例
		具體事物：貓，狗
		共性：姓名，年齡，吃飯

	分析：從具體到抽象
		貓:
			成員變數：姓名，年齡
			構造方法：無參，帶參
			成員方法：吃飯(貓吃魚)
			
		狗:
			成員變數：姓名，年齡
			構造方法：無參，帶參
			成員方法：吃飯(狗吃肉)
			
		因為有共性的內容，所以就提取了一個父類。動物。
		但是又由於吃飯的內容不一樣，所以吃飯的方法是抽象的，
		而方法是抽象的類，類就必須定義為抽象類。
		
		抽象動物類：
			成員變數：姓名，年齡
			構造方法：無參，帶參
			成員方法：吃飯();
	
	實現：從抽象到具體
		動物類:
			成員變數：姓名，年齡
			構造方法：無參，帶參
			成員方法：吃飯();
			
		狗類：
			繼承自動物類
			重寫吃飯();
			
		貓類：
			繼承自動物類
			重寫吃飯();
*/
//定義抽象的動物類
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();
		
		//練習：測試貓類
	}
	
}

抽象類練習老師案例：


/*
	老師案例
		具體事物：基礎班老師，就業班老師
		共性：姓名，年齡，講課。

	分析：	
		基礎班老師
			姓名，年齡
			講課。
		就業班老師
			姓名，年齡
			講課。
	實現：
		老師類
			基礎班老師
			就業班老師
*/
//定義抽象的老師類
abstract class Teacher {
	//姓名
	private String name;
	//年齡
	private int age;
	
	public Teacher() {}
	
	public Teacher(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 teach();
}

//基礎班老師類
class BasicTeacher extends Teacher {
	public BasicTeacher(){}
	
	public BasicTeacher(String name,int age) {
		super(name,age);
	}
	
	public void teach() {
		System.out.println("基礎班老師講解JavaSE");
	}
}

//就業班老師類
class WorkTeacher extends Teacher {
	public WorkTeacher(){}
	
	public WorkTeacher(String name,int age) {
		super(name,age);
	}
	
	public void teach() {
		System.out.println("就業班老師講解JavaEE");
	}
}

class AbstractTest2 {
	public static void main(String[] args) {
		//具體的類測試，自己玩
		
		//測試(多型)
		//基礎班老師
		Teacher t = new BasicTeacher();
		t.setName("劉意");
		t.setAge(30);
		System.out.println(t.getName()+"---"+t.getAge());
		t.teach();
		System.out.println("--------------");
		
		t = new BasicTeacher("劉意",30);
		System.out.println(t.getName()+"---"+t.getAge());
		t.teach();
		System.out.println("--------------");
		
		//就業班老師
		t = new WorkTeacher();
		t.setName("林青霞");
		t.setAge(27);
		System.out.println(t.getName()+"---"+t.getAge());
		t.teach();
		System.out.println("--------------");
		
		t = new WorkTeacher("林青霞",27);
		System.out.println(t.getName()+"---"+t.getAge());
		t.teach();
	}
}

抽象類練習學員案例：


/*
	學生案例
		具體事務：基礎班學員，就業班學員
		共性：姓名，年齡，班級，學習，吃飯

	分析：
		基礎班學員
			成員變數：姓名，年齡，班級
			成員方法：學習，吃飯
		就業班學員
			成員變數：姓名，年齡，班級
			成員方法：學習，吃飯
			
		得到一個學員類。
			成員變數：姓名，年齡，班級
			成員方法：學習，吃飯
			
	實現：
		學員類
		基礎班學員
		就業班學員
*/
//定義抽象學員類
abstract class Student {
	//姓名
	private String name;
	//年齡
	private int age;
	//班級
	private String grand;
	
	public Student() {}
	
	public Student(String name,int age,String grand) {
		this.name = name;
		this.age = age;
		this.grand = grand;
	}
	
	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 getGrand() {
		return grand;
	}
	
	public void setGrand(String grand) {
		this.grand = grand;
	}
	
	//學習
	public abstract void study();
	
	//吃飯
	public void eat() {
		System.out.println("學習累了,就該吃飯");
	}
}

//具體基礎班學員類
class BasicStudent extends Student {
	public BasicStudent() {}
	
	public BasicStudent(String name,int age,String grand) {
		super(name,age,grand);
	}
	
	public void study() {
		System.out.println("基礎班學員學習的是JavaSE");
	}
}

//具體就業班學員類
class WorkStudent extends Student {
	public WorkStudent() {}
	
	public WorkStudent(String name,int age,String grand) {
		super(name,age,grand);
	}
	
	public void study() {
		System.out.println("就業班學員學習的是JavaEE");
	}
}

class AbstractTest3 {
	public static void main(String[] args) {
		//我僅僅測試基礎班學員
		//按照多型的方式測試
		Student s = new BasicStudent();
		s.setName("林青霞");
		s.setAge(27);
		s.setGrand("1111");
		System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());
		s.study();
		s.eat();
		System.out.println("--------------");
		
		s = new BasicStudent("武鑫",48,"1111");
		System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());
		s.study();
		s.eat();
		
		//就業班測試留給自己玩
	}
}

抽象類練習員工案例：


/*
	假如我們在開發一個系統時需要對員工類進行設計，員工包含3個屬性：姓名、工號以及工資。
	經理也是員工，除了含有員工的屬性外，另為還有一個獎金屬性。
	請使用繼承的思想設計出員工類和經理類。要求類中提供必要的方法進行屬性訪問。
	
	分析：
		普通員工類
			成員變數：姓名、工號以及工資。
			成員方法：工作
		經理類：
			成員變數：姓名、工號以及工資，獎金屬性
			成員方法：工作
			
	實現：
		員工類：
		普通員工類：
		經理類：
*/
//定義員工類
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("-------------");
		

		//由於子類有特有的內容，所以我們用子類來測試
		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();
	}
}

抽象類中的小問題：


/*
一個類如果沒有抽象方法，可不可以定義為抽象類?如果可以，有什麼意義?
	可以。
	意義:不讓建立物件。你要訪問它，只能通過它的子類。

abstract不能和哪些關鍵字共存?
	private	衝突
	final	衝突	
	static	無意義
*/
abstract class Fu {
	//public abstract void show();為了讓子類重寫的
	
	//private abstract void show();//報錯:非法的修飾符組合: abstract和private，私有不能被繼承，子類也就不能重寫了，
	                               //而抽象類中的抽象方法是要求子類重寫的
	
	//報錯:非法的修飾符組合
	//final abstract void show();	
	
	//報錯:非法的修飾符組合，訪問一個沒有方法體的方法沒有意義
	static abstract void show();
	
	public static void method() {
		System.out.println("method");
	}
}

class Zi extends Fu {
	public void show() {}
}

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

JAVA物件導向--抽象類
2024-03-11
Java物件抽象
JavaSE第三章物件導向抽象類 abstract
2020-10-25
Java物件抽象
物件導向基礎(2)--抽象類介面集合泛型
2014-03-14
物件抽象泛型
[.net 物件導向程式設計基礎] (15) 抽象類
2015-06-07
物件程式設計抽象
Python 學習筆記之類「物件導向，超類，抽象」
2018-07-25
Python筆記物件抽象
物件導向 -- 三大特性之繼承補充抽象類介面類
2019-03-28
物件繼承抽象
章10——物件導向程式設計（高階部分）——抽象類
2024-09-05
物件程式設計抽象
Java第八課. 物件導向特徵3-多型&抽象類
2020-12-07
Java物件特徵多型抽象
Perl物件導向--類
2016-03-21
物件
Java物件導向——類與物件
2020-10-29
Java物件
JAVA學習線路：day01物件導向（繼承、抽象類）
2020-10-10
Java物件繼承抽象
python-程式導向、物件導向、類
2021-12-02
Python物件
物件導向類成員
2016-11-07
物件
python物件導向思想（類與物件）
2018-05-02
Python物件
PHP 物件導向（十一）反射類
2020-01-18
PHP物件反射
物件導向 -- 類的組合
2019-03-26
物件
C++ 類(物件導向初探)
2018-07-21
C++物件
物件導向之內部類
2020-10-17
物件
JavaScript中的物件導向----類
2008-09-24
JavaScript物件
物件導向——類設計（一）
2015-11-20
物件
JAVA物件導向高階二：抽象類的應用--模板方法設計模式
2024-03-23
Java物件抽象設計模式
物件導向-物件導向思想
2021-07-23
物件
Java語言之物件導向—類與物件（上）
2019-03-23
Java物件
SICP:構造過程抽象--物件導向的解釋
2021-04-08
抽象物件
python物件導向之抽象工廠設計模式
2018-12-12
Python物件抽象設計模式
PHP 物件導向（二）類屬性
2020-01-18
PHP物件
PHP物件導向(OOP)—-分頁類
2019-02-16
PHP物件OOP
物件導向的基本理論1：類和物件
2020-11-13
物件
PHP中物件導向的分頁類
2021-09-09
PHP物件
物件導向與人類的組織
2004-03-23
物件
程式導向與物件導向
2020-11-22
物件
物件導向與程式導向
2023-04-19
物件
“程序導向”和“物件導向”
2024-08-22
物件
課時37：類與物件：物件導向程式設計
2018-08-23
物件程式設計
物件導向
2024-09-04
物件
javascript物件導向包裝類Class的類庫解析
2013-05-22
JavaScript物件
物件導向，搞定物件
2019-07-19
物件
PHP 物件導向（九）物件導向三大特徵
2020-01-18
PHP物件特徵

物件導向-抽象類

相關文章