JAVA語言基礎-面向對象(接口）

面向對象(接口的概述及其特色)

• A:接口概述
  • 從狹義的角度講就是指java中的interface
  • 從廣義的角度講對外提供規則的都是接口
• B:接口特色
  • a:接口用關鍵字interface表示
    • interface 接口名 {}
  • b:類實現接口用implements表示
    • class 類名 implements 接口名 {}
  • c:接口不能實例化
    • 那麼，接口如何實例化呢?
    • 按照多態的方式來實例化。
  • d:接口的子類
    • a:能夠是抽象類。可是意義不大。
    • b:能夠是具體類。要重寫接口中的全部抽象方法。(推薦方案)
• C:案例演示
  • 接口特色    

class Demo1_Interface {
	public static void main(String[] args) {
		//Inter i = new Inter();		//接口不能被實例化,由於調用抽象方法沒有意義
		Inter i = new Demo();			//多態：父類引用指向子類對象
		i.print();
	}
}
/*
* A:接口概述
	* 從狹義的角度講就是指java中的interface
	* 從廣義的角度講對外提供規則的都是接口 
* B:接口特色
	* a:接口用關鍵字interface表示	
		* interface 接口名 {}
	* b:類實現接口用implements表示
		* class 類名 implements 接口名 {}
	* c:接口不能實例化
		* 那麼，接口如何實例化呢?
		* 按照多態的方式來實例化。
	* d:接口的子類
		* a:能夠是抽象類。可是意義不大。
		* b:能夠是具體類。要重寫接口中的全部抽象方法。(推薦方案)
* C:案例演示
	* 接口特色
*/

interface Inter {
	public abstract void print();					//接口中的方法都是抽象的
}

class Demo implements Inter {
	public void print() {
		System.out.println("print");
	}
}

面向對象(接口的成員特色)

• A:接口成員特色
  • 成員變量；只能是常量，而且是靜態的並公共的。 * 默認修飾符：public static final * 建議：本身手動給出。
  • 構造方法：接口沒有構造方法。
  • 成員方法：只能是抽象方法。 * 默認修飾符：public abstract * 建議：本身手動給出。
• B:案例演示
  • 接口成員特色 

class Demo2_Interface {
	public static void main(String[] args) {
		Demo d = new Demo();
		d.print();
		System.out.println(Inter.num);
	}
}
/*
* 成員變量；只能是常量，而且是靜態的並公共的。
			* 默認修飾符：public static final	三個關鍵字能夠互相交換位置
			* 建議：本身手動給出。
	* 構造方法：接口沒有構造方法。
	* 成員方法：只能是抽象方法。
			* 默認修飾符：public abstract
			* 建議：本身手動給出。
*/
interface Inter {
	public static final int num = 10;
	//public Inter(){}					接口中沒有構造方法

	/*public void print() {				接口中不能定義非抽象方法
	
	}*/

	public abstract void print();
}

class Demo /*extends Object*/ implements Inter {	//一個類不寫繼承任何類,默認繼承Object類
	public void print() {
		//num = 20;
		System.out.println(num);
	}

	public Demo() {
		super();
	}

}

面向對象(類與類,類與接口,接口與接口的關係)

• A:類與類,類與接口,接口與接口的關係
  • a:類與類：
    • 繼承關係,只能單繼承,能夠多層繼承。
  • b:類與接口：
    • 實現關係,能夠單實現,也能夠多實現。
    • 而且還能夠在繼承一個類的同時實現多個接口。
  • c:接口與接口：
    • 繼承關係,能夠單繼承,也能夠多繼承。
• B:案例演示
  • 類與類,類與接口,接口與接口的關係    

class Demo3_Interface {
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}

/*
* A:類與類,類與接口,接口與接口的關係
	* a:類與類：
		* 繼承關係,只能單繼承,能夠多層繼承。
	* b:類與接口：
		* 實現關係,能夠單實現,也能夠多實現。
		* 而且還能夠在繼承一個類的同時實現多個接口。
	* c:接口與接口：
		* 繼承關係,能夠單繼承,也能夠多繼承。
*/

interface InterA {
	public abstract void printA();
}

interface InterB {
	public abstract void printB();
}

interface InterC extends InterB,InterA {
}
//class Demo implements InterA,implements InterB {		//這麼作不容許是非法的
class Demo extends Object implements InterA,InterB {
	public void printA() {
		System.out.println("printA");
	}

	public void printB() {
		System.out.println("printB");
	}
}

面向對象(抽象類和接口的區別)

• A:成員區別

  • 抽象類：
    • 成員變量：能夠變量，也能夠常量
    • 構造方法：有
    • 成員方法：能夠抽象，也能夠非抽象
  • 接口：
    • 成員變量：只能夠常量
    • 成員方法：只能夠抽象

• B:關係區別

  • 類與類
    • 繼承，單繼承
  • 類與接口
    • 實現，單實現，多實現
  • 接口與接口
    • 繼承，單繼承，多繼承

• C:設計理念區別

  • 抽象類 被繼承體現的是：」is a」的關係。抽象類中定義的是該繼承體系的共性功能。
  • 接口 被實現體現的是：」like a」的關係。接口中定義的是該繼承體系的擴展功能。

面向對象(貓狗案例加入跳高功能分析及其代碼實現)

• A:案例演示
  • 動物類：姓名，年齡，吃飯，睡覺。
  • 貓和狗
  • 動物培訓接口：跳高    

class Test1_Animal {
	public static void main(String[] args) {
		Cat c = new Cat("加菲",8);
		c.eat();
		c.sleep();

		JumpCat jc = new JumpCat("跳高貓",3);
		jc.eat();
		jc.sleep();
		jc.jump();
	}
}

/*
* A:案例演示
	* 動物類：姓名，年齡，吃飯，睡覺。
	* 貓和狗
	* 動物培訓接口：跳高
*/

abstract class Animal {
	private String name;				//姓名
	private int age;					//年齡

	public Animal() {}					//空參構造

	public Animal(String name,int age) {//有參構造
		this.name = name;
		this.age = age;
	}

	public void setName(String name) {	//設置姓名
		this.name = name;
	}

	public String getName() {			//獲取姓名
		return name;
	}

	public void setAge(int age) {		//設置年齡
		this.age = age;
	}

	public int getAge() {				//獲取年齡
		return age;
	}

	public abstract void eat();			//吃飯

	public abstract void sleep();		//睡覺
}

interface Jumping {						//跳高的接口
	public void jump();
}

class Cat extends Animal {
	public Cat() {}					//空參構造

	public Cat(String name,int age) {//有參構造
		super(name,age);
	}

	public void eat() {
		System.out.println("貓吃魚");
	}

	public void sleep() {
		System.out.println("側着睡");
	}
}

class JumpCat extends Cat implements Jumping {
	public JumpCat() {}					//空參構造

	public JumpCat(String name,int age) {//有參構造
		super(name,age);
	}

	public void jump() {
		System.out.println("貓跳高");
	}
}