java學習第六天

 

抽象類
一、抽象使用abstract 關鍵字修飾
二、沒法生成具體的實例
三、能夠定義屬性(普通的，靜態，其餘)
四、能夠定義方法(普通的，靜態，抽象的)
五、有構造函數，可是不能本身用，只能被子類實現
六、能夠繼承其餘的類，可是隻能單繼承
七、抽象類重點關注的是類的抽象

 

接口：
一、特殊的抽象類，裏面都是抽象方法， jdk1.8以後可使用虛方法
二、只能被普通類實現
三、能夠被其餘接口繼承，也能夠繼承其餘接口，且是多繼承
四、接口關注的是功能(方法的抽象)
五、接口的屬性 只能用 public  static  final修飾的常量

 

 

 

 

 

/*
 * 抽象類：
 * 一、使用 abstract 關鍵字進行修飾的類
 * 二、不能被實例化
 * 三、存在構造方法，由於子類須要實例化父類
 * 四、存在普通方法， 能夠存在靜態
 * 五、
 * 屬性 
 *  跟普通類用法如出一轍
 * 
 * 方法   -- 構造    普通   靜態  
 *  //abstract returnType abstractMethod([paramlist])
 *
 * 一、抽象方法
 *  1>使用 abstract 修飾的方法
 *  2>方法沒有方法體  就是沒有大括號
 *  3>子類必須重寫父類中的抽象方法，若是不重寫，那麼子類必須聲明爲抽象類
 *   若是子類沒有所有重寫父類抽象方法，那麼子類也必須是抽象類
 *    得出的結論：有抽象方法的類，這個類必須是抽象類，反之，抽象類，不必定有抽象方法。
 *
 * abstract  final
 *  fianl 修飾方法 /類是最終方法/類，不能被重寫或繼承，
 *  因此 final 不能跟abstract 同時出現
 *
 * abstract static
 *  static 修飾的方法是不能被子類重寫的，因此static 跟 abstract 是不能同時出現的
 *
 * abstract 能不能修飾 構造函數
 * abstract 修飾的方法必須得重寫，而構造函數不能被重寫，因此不能同時使用
 *
 *
 * 運用場景：抽象類  --- > 模板設計模式   ---> 數據庫操做
 *  子類繼承父類，要求必須實現某種功能，而實現的邏輯必須按照父類制定的格式
 *
 *
 *
 */

//抽象類

public abstract class AbstraDemo {
 public String name;
 
 //能夠存在構造方法，由於子類須要實例化父類
 //Illegal modifier for the constructor in type AbstraDemo;
 //only public, protected & private are permitted
 AbstraDemo(){
  
 }
 
 //普通方法
 public void method(){
  
 }

 //抽象方法
 public abstract void absMethod();
 
 public abstract void absMethod2();
 
 
 
 
 
 
 
 
 public static void main(String[] args) {
  //Cannot instantiate the type AbstraDemo
  //實例化，不能被實例化
  //AbstraDemo sAbstraDemo = new  AbstraDemo();
  
  //不叫實例化，匿名內部類
  /**
   * 等價於
   * Sub  extends AbstraDemo
   * sAbstraDemo = new Sub();
   */
  //AbstraDemo sAbstraDemo = new  AbstraDemo() {};
  
 }
}

 

 

子類

public class GSubAbstra extends SubAbstra{

 @Override
 public void absMethod() {
  
 }
}

 

子類

public abstract class SubAbstra extends AbstraDemo{

 @Override
 public void absMethod2() {
  
 }
}

 

---------------------------------------------------------------------

接口

//接口
//抽象       類中的公共的功能
//從本質上講，接口是一種特殊的抽象類，這種抽象類中只包含常量和方法的定義，
//而沒有變量和方法的實現。
//接口是一個特殊的抽象類，只有抽象方法的抽象類  把 class  ---》 interface
//一、接口是類，它的修飾符跟類同樣，public 跟默認

接口Fly

 public interface Fly {
 //常量定義
 //不能修飾 private   protected  由於默認 public  static final
 //接口中定義的屬性默認的是public 即便不寫修飾符，依然是public
 //接口中定義的屬性默認的是static  即便不寫static修飾符，依然是static
 //接口中定義的屬性默認的是final 即便不寫final修飾符，依然是final
 int intField= 1;
 //等價於：public  static final int intField= 1;
 
 
 //方法的定義
 //Illegal modifier for the interface method fly; 
 //only public, abstract, default, static and strictfp are permitted
 //jdk 1.8 之後的新特性  default   strictfp  static
 //接口中定義的方法默認的是public 即便不寫修飾符，依然是public
 //接口中定義的方法默認的是abstract 即便不寫修飾符，依然是abstract
 //接口中定義的方法不是靜態的
 public void fly();
 public void down();
 
 
 
}

接口 Turn

public interface Turn {
 public void turn();
}

 

 

子類
     子類經過 implements 實現接口

public class Kite implements Fly{

 @Override
 public void fly() {
  System.out.println("風箏起風了...");
 }

 @Override
 public void down() {
  System.out.println("風箏短線了...");
 }

}

 

子類

public class Plane implements Fly{
 @Override
 public void fly() {
  System.out.println("飛機起飛了....");
 }

 @Override
 public void down() {
  System.out.println("飛機墜毀了....");
 }
}

 

 

//具體類實現了接口，必須得重寫接口中抽象方法
//具體的類，能夠實現多個接口，使用 , 分開
//類是單繼承，接口是多繼承
 //一、 類只有一個直接父類
 //二、 類能夠實現多個接口
 //三、接口能夠實現多繼承

接口 FlyAndTurn

public interface  FlyAndTurn extends Fly, Turn{

}

子類
   
     public class Plane2 implements FlyAndTurn{

 @Override
 public void fly() {
 }

 @Override
 public void down() {
 }

 @Override
 public void turn() {
 }

}

------------------------------------------------------------------------
接口例子1

接口 Runner

public interface Runner {
 public void start();
 public void run();
 public void stop();
}

子類   Person

    public class Person implements Runner {

 @Override
 public void start() {
  System.out.println("Person.start()");
 }

 @Override
 public void run() {
  System.out.println("Person.run()");
 }

 @Override
 public void stop() {
  System.out.println("Person.stop()");
 }
}

 

子類   Car

    public class Car implements Runner {

 @Override
 public void start() {
  System.out.println("Car.start()");
 }

 @Override
 public void run() {
  System.out.println("Car.run()");
 }

 @Override
 public void stop() {
  System.out.println("Car.stop()");
 }
}

 

子類  Bird

    public class Bird implements Runner {

 @Override
 public void start() {
  System.out.println("Bird.start()");
 }

 @Override
 public void run() {
  System.out.println("Bird.run()");
 }

 @Override
 public void stop() {
  System.out.println("Bird.stop()");
 }

}

------------------------------------------------------
接口例子2

接口 interface

public interface Fly {
 void fly();
}

 

子類  Bird

public class Bird implements Fly{

 @Override
 public void fly() {
  System.out.println("Bird.fly()");
 }
}

子類   Plane

public class Plane implements Fly{
 @Override
 public void fly() {
  System.out.println("Plane.fly()");
 }
}

普通類 Sky

public class Sky {
 
 //接口的多態
 public void trace(Fly fly){
  if (fly instanceof Bird) {
  }
  fly.fly();
 }
 
}

測試類   Test

import com.qiangfei.demo1.Plan;

public class Test { public static void main(String[] args) {    //匿名內部類  /*Fly fly = new Fly() {   @Override   public void fly() {       }  };*/  //報錯：由於接口是抽象的，不能new 對象  //Fly fly = new Fly();    //向上轉型   -- 類比 類的繼承  Fly fly = new Bird();  //fly.fly();   //接口的多態表現形式    Plane  plane = new Plane();    Sky sky = new Sky();  sky.trace(fly);   //鳥飛過  sky.trace(plane);    //向下轉型  Bird bird = (Bird) fly;  bird.fly();  //java.lang.ClassCastException  plane = (Plane) fly;   }}