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);
}
}