Java-接口和多態

接口

接口Interface，接口和類的關係是實現，implements
Interface 接口名{
}

package com.it01;
/*
 * 	java用於處理繼承的單一侷限性---接口Interface，接口和類的關係是實現，implements
 * 
 *  	創建接口的格式
 *  		Interface 接口名{
 *  			}
 */
public class InterfaceDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BillGates bg =new BillGates();
		bg.code();
	}

}

class Boss{
	public void manage() {
		System.out.println("管理公司");
	}
}

class Programmer{
	public void code() {
		System.out.println("敲代碼");
	}
}

class BillGates extends Programmer{
	
}

接口的成員特點：

• 只能有常量
• 常量使用public static final修飾
• 只能有抽象方法
• 成員方法默認使用public&abstract修飾

建議手動添加修飾符
注意：

-類和接口是實現關係
類和接口是實現關係—一個類實現一個接口必須實現它所有的方法
接口不能創建對象（實例化）

package com.it01;

public class InterfaceDemo2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}
//接口
interface Animal{
	public static  final int num=30;
	public abstract void eat();
}


//類和接口是實現關係
class Cat implements Animal{

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("我要吃魚");
	}
	
}

package com.it01;
/*
 * 	類與類的關係--繼承關係，單一繼承，多層繼承
 * 	類與接口---實現關係,多實現
 * 	接口與接口的關係----可繼承關係，多繼承
 */
public class InterfaceDemo3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}

//接口
interface InterA{
	public abstract void method();
}

interface InterB{
	public abstract void method();
}

interface InterC extends InterA{
	public abstract void method();
}

class Demo implements InterA,InterB{

	@Override
	public void method() {
		// TODO Auto-generated method stub
		
	}
	
}

接口的優點：
1.類與接口的關係：實現關係，而且是多實現，一個類可以實現多個接口，類與類之間是繼承關係，打破了繼承的侷限性。
2.對外提供規則，提供規範
3.降低了程序的耦合性，可以實現模塊化開發，提高了開發效率

接口和抽象類的區別：

• [ 1] 共性：不斷的抽取，抽取出抽象的概念
• [2]區別：
  1.與類的關係
  類與接口的關係：實現關係，而且是多實現，一個類可以實現多個接口，並把抽象方法全部實現
  類與類之間是繼承關係，只能是單一繼承和多層繼承。
  2.成員
  成員變量：
  抽象類有成員變量和成員常量
  接口只能有常量
  成員方法：
  抽象類可以有抽象方法和非抽象方法
  接口只能有抽象類，而且方法修飾符有默認修飾符
  構造方法：
  抽象類有構造方法
  接口沒有構造方法

接口案例
案例分析

案例代碼

package com.it02;
/*
 * 	運動員案例
 * 	分析
 * 		由下至上    不斷向上抽取
 * 	實現
 * 		由上至下    先實現共性
 */
public class InterfaceTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//創建籃球運動員和教練
		BasketballPlayer bp0 = new BasketballPlayer("王治郅",18,"男");
		BasketballPlayer bp = new BasketballPlayer();
		bp.name="郭艾倫";
		bp.age=29;
		bp.gender="男";
		bp.sleep();
		bp.study();
		bp.speak();
		
		BasketballCoach bc = new BasketballCoach();
		bc.name="姚明";
		bc.age=32;
		bc.gender="男";
		bc.sleep();
		bc.teach();;
		bc.speak();
		
		//創建乒乓球運動員和教練
		

	}

}

//人的類
class Person{
	String name;
	int age;
	String gender;
	
	//無參構造方法
	public Person() {
		// TODO Auto-generated constructor stub
		super();
	}

	
	
	//有參構造
	public Person(String name, int age, String gender) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	
	//成員方法
	public void eat() {
		System.out.println("吃飯");
	}
	
	public void sleep() {
		System.out.println("睡覺");
	}
}

//運動員
abstract class Player extends Person{
	
	public Player() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Player(String name, int age, String gender) {
		super(name, age, gender);
		// TODO Auto-generated constructor stub
	}

	public abstract void study();
}

//教練員
abstract class Coach extends Person{
	
	public Coach() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Coach(String name, int age, String gender) {
		super(name, age, gender);
		// TODO Auto-generated constructor stub
	}

	public abstract void teach();
}
//英語
interface SpeakEnglish{
	public abstract void speak();
}

//實現類
//籃球運動員
class BasketballPlayer extends Player implements SpeakEnglish{
	
	


	public BasketballPlayer() {
		super();
		// TODO Auto-generated constructor stub
	}

	public BasketballPlayer(String name, int age, String gender) {
		super(name, age, gender);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void study() {
		// TODO Auto-generated method stub
		System.out.println("學習扣籃");
	}

	@Override
	public void speak() {
		// TODO Auto-generated method stub
		System.out.println("學英語");
		
	}
	
}
//乒乓球運動員
class PingpangPlayer extends Player{
	
	

	public PingpangPlayer() {
		super();
		// TODO Auto-generated constructor stub
	}

	public PingpangPlayer(String name, int age, String gender) {
		super(name, age, gender);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void study() {
		// TODO Auto-generated method stub
		System.out.println("學習抽球");
	}
	
}

//籃球教練
class BasketballCoach extends Coach implements SpeakEnglish{
	
	


	public BasketballCoach() {
		super();
		// TODO Auto-generated constructor stub
	}

	public BasketballCoach(String name, int age, String gender) {
		super(name, age, gender);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void teach() {
		// TODO Auto-generated method stub
		System.out.println("教扣籃");
	}

	@Override
	public void speak() {
		// TODO Auto-generated method stub
		System.out.println("學英語");
	}
	
}

//乒乓球教練

class PingpangCoach extends Coach{

	
	public PingpangCoach() {
		super();
		// TODO Auto-generated constructor stub
	}

	public PingpangCoach(String name, int age, String gender) {
		super(name, age, gender);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void teach() {
		// TODO Auto-generated method stub
		System.out.println("教抽球");
	}
	
}

匿名對象

package com.it03;
/*
 * 	匿名對象：沒有名字的對象
 * 	匿名對象的應用場景：
 * 		當方法之帶調用一次的時候可以使用匿名對象
 * 		可以當作參數進行傳遞，但是無法在傳參之前做其他的事請
 * 		
 * 	注意：匿名對象可以創建成員變量並賦值，但沒有意義
 */
public class AnonymousObjectDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//Student s = new Student();
		//s.study();
		
		//new Student();//匿名對象，沒有變量引用的對象
		new Student().study();
		new Student().study();
		new Student().study();
		
		//調用method方法
		method(new Student());
	}
	
	public static void method(Student s) {
		System.out.println("調用method方法");
	}

}

class Student{
	String name;
	int age;
	public void study() {
		System.out.println("學習是主要任務");
	}
}

final關鍵字

package com.it03;
/*
 * 	final：修飾符，可以用於修飾類、成員方法和成員變量
 * 	final所修飾的類，不能被繼承，不能有子類
 * 	final所修飾的方法在子類中不能被重寫
 * 	final所修飾的變量：不可以修改的，是常量
 * 
 * 	常量：
 * 		字面值常量
 * 		自定義常量：被final修飾的變量，一旦賦值不可修改（必須被初始化）
 */
public class FinalDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Animal a= new Animal();
		a.eat();
	}

}

final class Animal {
	public void eat() {
		System.out.println("吃東西");
	}
}

多態

多態的三個要素：

• 子父類繼承關係
• 方法的重寫
• 父類引用指向子類對象

動態綁定

• 運行期間-調用的方法是根據其具體的類型

package com.it04;

public class PoymorphicDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Cat c = new Cat();
		c.eat();
		
		//父類引用Animal a
		//指向=
		//子類對象new Cat()
		Animal a = new Cat();
		a.eat();
	}

}


class Animal{
	public void eat() {
		System.out.println("吃東西");
	}
}

class Cat extends Animal{
	//方法的重寫
	public void eat() {
		System.out.println("貓吃🐟");
	}
}

多態的成員特點

1. 成員變量-編譯時看到是左邊，運行時也看得左邊
2. 成員方法-編譯時看到是左邊，運行時也看得右邊
3. 靜態方法-編譯時看到是左邊，運行時也看得左邊

編譯時看的都是左邊，運行時成員方法看的右邊，其他看的左邊

package com.it04;

public class PoymorphicDemo2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Dad d = new Kid();
		System.out.println(d.num);//20
		
		d.method();//我是父類方法
		
		d.function();//我是父類靜態方法(使用變量去調用靜態方法，其實相當於使用變量類型的類名去調用)
	}

}

class Dad {
	int num=20;
	public void method() {
		System.out.println("我是父類方法");
	}
	public static void function() {
		System.out.println("我是父類靜態方法");
	}
}

class Kid extends Dad{
	int num=10;
	public void method() {
		System.out.println("我是子類方法");
	}
	public static void function() {
		System.out.println("我是子類靜態方法");
	}
}

多態中的向上轉型和向下轉型

package com.it04;
/*
 * 	多態中的向上轉型和向下轉型
 * 	引用類型之間的轉換
 * 		向上轉型-由小到大
 * 		向下轉型-由大到小
 * 
 * 	基本數據類型的轉換
 * 		自動轉換-由小到大
 * 		強制類型轉換-由大到小
 */
public class PoymorphicDemo3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Animals a = new Dog();//向上轉型
		
		a.eat();
		
		Dog d = (Dog)a;//向下轉型
		d.eat();
		d.swim();
	}

}

class Animals{
	public void eat() {
		System.out.println("吃東西");
	}
}

class Dog extends Animals{
	public void eat() {
		System.out.println("啃骨頭");
	}
	
	public void swim() {
		System.out.println("狗刨");
	}
}

多態的優缺點

• 缺點：
  無法直接訪問子類特有的成員

• 優點：
  可以提高可維護性
  提高代碼的可擴展性

package com.it04;
/*
 * 	多態可以提高代碼的可擴展性
 */
public class PoymorphicDemo4 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//創建工廠類對象
		Factory f = new Factory();
		f.CreatPhone(new HuaWei());
		f.CreatPhone(new XiaoMi());
	}

}

//定義接口
interface Phone{
	public void call();
}

class HuaWei implements Phone{

	@Override
	public void call() {
		// TODO Auto-generated method stub
		System.out.println("華爲手機，中華有爲");
	}
	
}

class XiaoMi implements Phone{

	@Override
	public void call() {
		// TODO Auto-generated method stub
		System.out.println("小米手機，性價比之王");
	}
	
}

//定義生產手機的工廠類
class Factory {
	public void CreatPhone(Phone p) {
		p.call();
	}
}