java学习第六天

2019独角兽企业重金招聘Python工程师标准>>>

 

抽象类
1、抽象使用abstract 关键字修饰
2、无法生成具体的实例
3、可以定义属性(普通的，静态，其他)
4、可以定义方法(普通的，静态，抽象的)
5、有构造函数，但是不能自己用，只能被子类实现
6、可以继承其他的类，但是只能单继承
7、抽象类重点关注的是类的抽象

 

接口：
1、特殊的抽象类，里面都是抽象方法， jdk1.8之后可以使用虚方法
2、只能被普通类实现
3、可以被其他接口继承，也可以继承其他接口，且是多继承
4、接口关注的是功能(方法的抽象)
5、接口的属性 只能用 public  static  final修饰的常量

 

 

 

 

 

/*
 * 抽象类：
 * 1、使用 abstract 关键字进行修饰的类
 * 2、不能被实例化
 * 3、存在构造方法，因为子类需要实例化父类
 * 4、存在普通方法， 可以存在静态
 * 5、
 * 属性 
 *  跟普通类用法一模一样
 * 
 * 方法   -- 构造    普通   静态  
 *  //abstract returnType abstractMethod([paramlist])
 *
 * 1、抽象方法
 *  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
//1、接口是类，它的修饰符跟类一样，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("飞机坠毁了....");
 }
}

 

 

//具体类实现了接口，必须得重写接口中抽象方法
//具体的类，可以实现多个接口，使用 , 分开
//类是单继承，接口是多继承
 //1、 类只有一个直接父类
 //2、 类可以实现多个接口
 //3、接口可以实现多继承

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

转载于:https://my.oschina.net/u/2542711/blog/539844