java抽象類 和介面
阿新 • • 發佈：2018-12-20
1.抽象類
public abstract class People { private String name; private int age; private String sex; private final int a = 20; public abstract void eat(); public abstract void work(); public abstract void a(); public abstract void b(); public abstract void c(); public abstract void d(); public abstract void e(); public abstract void f(); public abstract void g(); public void sleep(){ System.out.println("睡覺"); } 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 getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } public People(String name, int age, String sex) { super(); this.name = name; this.age = age; this.sex = sex; } public People() { super(); // TODO Auto-generated constructor stub } }
public abstract class Student extends People { public Student() { //super(); } public static void main(String[] args) { //People p1 = new Student(); } @Override public void eat() { System.out.println("學生吃肉"); } @Override public void work() { System.out.println("學習"); } }
public abstract class Teacher extends People { @Override public void eat() { // TODO Auto-generated method stub } @Override public void work() { // TODO Auto-generated method stub } @Override public void a() { // TODO Auto-generated method stub } @Override public void b() { // TODO Auto-generated method stub } }
public abstract class Doctor extends People {
@Override
public void eat() {
// TODO Auto-generated method stub
}
@Override
public void work() {
// TODO Auto-generated method stub
}
@Override
public void a() {
// TODO Auto-generated method stub
}
@Override
public void b() {
// TODO Auto-generated method stub
}
@Override
public void c() {
// TODO Auto-generated method stub
}
@Override
public void d() {
// TODO Auto-generated method stub
}
@Override
public void e() {
// TODO Auto-generated method stub
}
@Override
public void f() {
// TODO Auto-generated method stub
}
@Override
public void g() {
// TODO Auto-generated method stub
}
}
public class Test {
/*
* 抽象類的學習
*
* 抽象類:把子類中那些具有共同屬性以及共同行為的特性，歸納，總結出一個父類，我們把這個父類，稱為抽象類
* 雖然我們口頭上稱這種類為抽象類，但是java語法結構上並沒有體現出這種抽象的概念
* 那麼怎麼讓一個類變為抽象類？
*
* 1：給類加關鍵字：abstract
* 語法格式
* public abstract class 類名{
*
* }
* 2:如果一個類中有抽象方法，那麼這個類一定是抽象類
* 抽象方法 語法格式:抽象方法只有方法宣告，沒有方法體。
* 修飾符 abstract 返回值 方法名();
*
* 3:如果一個類繼承了抽象類
* 那麼這個類
* 1：要麼重寫父類中所有抽象方法
* 2：要麼自己變成抽象類
*
* 抽象類的作用？
* 1:減少了抽象類中方法體的寫法，提高了部分效率
* 2:規定了一個類必須做什麼，約束了子類的行為，大大的增強了類的範圍性，使得一個類在設計的時候，不是那麼的隨意
* 但是正因為類的規範性，使得類與類之間的耦合關係大大增加，無形之中給子類增加了負擔
*
* 抽象類的細節處理
* 1：抽象類是否有變數:有
* 2：抽象類是否有常量:有
* 3：抽象類是否有抽象方法
* 3.1 抽象類中可以沒有抽象方法，也可以有
* 3.2 有抽象方法的類,必須是抽象類
* 4:抽象類是否有成員方法:有
* 5:抽象類是否有構造方法:有
* 6:抽象類是否可以建立物件:不可以建立物件
* 7:每個類至少會提供一個構造方法
* 7.1:向上引用，呼叫父類的構造方法
* 7.2:初始化屬性值
* 8:抽象類就是為了被繼承的，如果沒有子類繼承，抽象類沒有任何作用
* 9:所以多型的特性，在抽象類最能體現出來，因為多型的前提是繼承
*
*
*
*/
public static void main(String[] args) {
//People p = new People();
//People p = new Student(); //多型 向上轉型
}
}
2.介面
public abstract class People {
private String name;
private int age;
private String sex;
public abstract void eat();
public void sleep(){
System.out.println("躺著睡");
}
public abstract void work();
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 getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public People(String name, int age, String sex) {
super();
this.name = name;
this.age = age;
this.sex = sex;
}
public People() {
super();
// TODO Auto-generated constructor stub
}
}
public class Student extends People {
@Override
public void eat() {
System.out.println("學生吃肉");
}
@Override
public void work() {
System.out.println("學JAVA");
}
public void playGame(){
System.out.println("LOL");
}
}
public class Teacher extends People {
@Override
public void eat() {
System.out.println("老師吃菜");
}
@Override
public void work() {
System.out.println("教JAVA");
}
public void running(){
System.out.println("跑步");
}
}
public interface SmokeInter {
//抽菸行為
void smoking();
}
public class SmokeStudent extends Student implements SmokeInter{
@Override
public void smoking() {
System.out.println("學生抽菸");
}
}
public class SmokeTeacher extends Teacher implements SmokeInter {
@Override
public void smoking() {
System.out.println("老師抽菸");
}
}
public class Test {
/*
* 父類：People
* 1個實現的方法：sleep()
* 2個抽象的方法：eat() work()
* 子類1：Student
* 繼承父類的方法：sleep()
* 重寫父類的方法：eat() work()
* 自己的方法：playGame()
* 子類2：Teacher
* 繼承父類的方法：sleep()
* 重寫父類的方法：eat() work()
* 自己的方法：running()
* 介面：SmokeInter 抽菸介面
*
* 實現類1：SmokeStudent extends Student implements SmokeInter
*
* 實現類2：SmokeTeacher extends Teacher implements SmokeInter
*
*
* 新的需求：需要加一個抽菸的方法，問題是這個方法應該定義在哪個類中？
* 問題1：抽菸是一個行為，它並不屬於任何一個類
* 解決方法：把抽菸這個行為，定義在抽菸的介面中
*
* 介面：USB介面，可以連線電腦和鍵盤，介面起到了一個橋樑作用
* 類：電腦類和鍵盤類
* 如何讓電腦和鍵盤產生聯絡
* 1：繼承方案
* 繼承會是兩個2類產生耦合關係
* 2：介面方案
* 電腦通過一個介面把鍵盤聯絡起來，用的時候插上，不用的時候拔掉，起到一個即插即用的功能
* 介面是類與類之間一個橋樑，起到了一個聯通的作用，既不產生耦合關係，而且功能越來越強大
* 一個類可以連線多個介面，突破了一個類原本的型別限制，使得整個類的功能很豐富
*
* 介面的語法格式:
* interface
*
* 修飾符 interface 介面名(){
* ...
* }
*
* 如何讓一個類實現介面
* 修飾符 class 類名 implements 介面名{
*
* }
*
* 全棧工程師
*/
public static void main(String[] args) {
//建立一個抽菸的學生物件
People stu1 = new SmokeStudent();
People p = new SmokeTeacher();
People p1 = new Student();
People p2 = new Teacher();
//優點:可以接受不同型別的物件
//缺點:多型不能呼叫子類獨有的方法
System.out.println("---普通人類---");
stu1.eat();
stu1.sleep();
stu1.work();
Student stu2 = new SmokeStudent();
System.out.println("---普通學生---");
stu2.eat();
stu2.sleep();
stu2.work();
stu2.playGame();
SmokeStudent stu3 = new SmokeStudent();
//優點：既能呼叫繼承父類的方法，也能呼叫自己獨有的方法，功能強大
//缺點：型別單一，如果把真個型別作為方法的形參的話，功能單一
System.out.println("-----抽菸的學生-------");
stu3.eat();
stu3.sleep();
stu3.work();
stu3.playGame();
stu3.smoking();
}
}
```
public class Test {
/*
* 介面和實現類起名規則
*
* 例如： 介面名稱：StudentDao，StudentService
* 實現類：StudentDaoImpl，StudentServiceImpl
*
*/
}
```
```
public interface TestInter {
/*
* 介面的內部結構
*
* 1：介面是否有變數:沒有
* 2：介面是否有常量:有
* 預設修飾符 public static final
* 3：介面是否有實現方法:沒有
* 注意 jdk1.8之前沒有
* 1.8之後有了，靜態實現方法，預設方法
* 4：介面是否有抽象方法：有
* 預設修飾符 public abstract 返回值 方法名();
* 5：介面是否有構造方法:沒有
* 介面不是類，所以也就沒有必要寫構造器
*
* 抽象類是為了被繼承的
* 介面是為了被實現的
*/
int a = 10;
final int b = 20;
/*
default void ss(){
}
*/
void s();
}
3.抽象類與介面
public interface A extends D,E {
}
public abstract class B extends C implements A,D{
}
public class C{
}
public interface D {
public void show();
public void main(String[] args) ;
}
public interface E {
//public abstract void show();
}
```
```
public class Test {
/*
* 介面的用法
* A:介面
* B實現類，C實現類
*
* A a = new B();
* 等號左邊是介面型別，右邊是實現類的物件
* 多型的重要體現形式：向上轉型
*
* 實際開發中，方法的形參是介面型別，實際上需要我們傳入一個實現類物件
* 實際開發中，方法的形參是抽象類，實際上需要我們傳入一個子類物件
*
* 面向介面程式設計：有利於大型專案的的可擴充套件和可維護性
*
* 類與類的關係
* 繼承，單繼承，但是有繼承鏈
* 類與介面的關係
* 實現關係，多實現
* 介面和介面的關係
* 繼承關係，多繼承
* java的的最基本的2大組織結構：類與介面
* 介面把方法定義好，等著實現類來實現
* 實際開發，先定義介面，在寫具體的實現類
* 注意：一個類既能繼承父類，還能實現介面，但是必須先繼承，後實現
*
*
* 面試題：介面和抽象類的區別？
* 1：方法實現
* 抽象類可以有實現方法
* 介面沒有，1.8之後有了,可以有靜態方法，預設方法
* 2：實現方式
* 抽象類是extends繼承的
* 介面是implements實現的
* 3 構造器
* 抽象類可以有構造器
* 介面不能有構造器
* 4：方法修飾符
* 抽象類的抽象方法可以有public、protected和default這些修飾符
* 介面方法預設修飾符是public。你不可以使用其它修飾符。
* 5:繼承
* 抽象類的抽象方法可以繼承一個類和實現多個介面
* 介面可以繼承一個或多個其它介面
*
* 什麼時候使用抽象類和介面？
* 具體類 is..a 抽象類 是什麼 類的說法
* 抽菸的學生是學生
* 狗是一個動物
*
* ..like..a.. 像什麼
* 如果你的類的功能，是由很多不同之間的功能組合而成，那麼應該使用介面多實現的方式
*
*
* 定義一個抽象類 Animal 3個方法 吃飯 睡覺 工作
* 2個子類：Dog，Cat
* 定義2個介面 狗要鑽火圈，貓要算算數
* 定義2個子類 鑽火圈的狗，算算術的貓
*
*
*/
public void show(A a){
}
public static void main(String[] args) {
//A a = new A();
//A a = new B();
//A a1 = new C(); //面向介面程式設計
//B b1 = new B(); //面向物件程式設計
//Test t = new Test();
//t.show(a);
//t.show(a1);
//System.out.println(a);
}
}