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