物件導向-抽象類
抽象類的特點：
/*
抽象類的概述：
動物不應該定義為具體的東西，而且動物中的吃，睡等也不應該是具體的。
我們把一個不是具體的功能稱為抽象的功能，而一個類中如果有抽象的功能，該類必須是抽象類。
抽象類的特點：
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物件導向--抽象類Java物件抽象
- Python 學習筆記之類「物件導向，超類，抽象」Python筆記物件抽象
- JavaSE第三章 物件導向 抽象類 abstractJava物件抽象
- 物件導向 -- 三大特性之繼承 補充 抽象類 介面類物件繼承抽象
- 章10——物件導向程式設計（高階部分）——抽象類物件程式設計抽象
- Java第八課. 物件導向特徵3-多型&抽象類Java物件特徵多型抽象
- python-程式導向、物件導向、類Python物件
- Java物件導向——類與物件Java物件
- JAVA學習線路：day01物件導向（繼承、抽象類）Java物件繼承抽象
- python物件導向思想（類與物件）Python物件
- python物件導向之抽象工廠設計模式Python物件抽象設計模式
- JAVA物件導向高階二：抽象類的應用--模板方法設計模式Java物件抽象設計模式
- 物件導向 -- 類的組合物件
- C++ 類(物件導向初探)C++物件
- PHP 物件導向 （十一）反射類PHP物件反射
- 物件導向之內部類物件
- 物件導向-物件導向思想物件
- Java語言之物件導向—類與物件（上）Java物件
- SICP:構造過程抽象--物件導向的解釋抽象物件
- PHP物件導向(OOP)—-分頁類PHP物件OOP
- PHP 物件導向 （二）類屬性PHP物件
- 物件導向的基本理論1：類和物件物件
- PHP中物件導向的分頁類PHP物件
- python中物件導向_類_物件的概念與定義Python物件
- 課時37：類與物件：物件導向程式設計物件程式設計
- 物件導向與程式導向物件
- 程式導向與物件導向物件
- “程序導向”和“物件導向”物件
- Python - 物件導向程式設計 - 什麼是 Python 類、類物件、例項物件Python物件程式設計
- 物件導向物件
- 物件導向，搞定物件物件
- JAVA物件導向基礎--物件導向介紹Java物件
- PHP 物件導向 （九）物件導向三大特徵PHP物件特徵
- 【python】物件導向之類成員(屬性)Python物件
- Python如何設計物件導向的類（下）Python物件
- Python如何設計物件導向的類（上）Python物件
- 談談我對物件導向以及類與物件的理解物件
- PHP 物件導向 （四）類物件賦值為引用傳遞PHP物件賦值
- 物件導向中類和物件的定義是什麼?物件