抽象类及接口

1,单词：biology生物 interface接口， abstract 抽象的 major 专业

Illegal 不合法的

2,abstract介绍

abstract:关键字，表示抽象的

 * abstract修饰方法表示：表示给方法没有方法体，就是没有{}

 * ，并且，一旦类中存在抽象方法，给类必须使用abstract，表示该类是抽象类

 * abstract修饰的类型中，是可以不存在abstract方法的

 * 抽象类中，不一定存在抽象方法，但抽象方法所在的类一定是抽象类。

 * 抽象类的特点

 * 抽象类有构造方法，但抽象类不能被实例化：

 * 因为抽象类不能实例化对象，但为什么还有构造方法呢

 * 是为了给成员变量初始化用的。是在子类构造方法中，通过super（String int）的形式来初始化抽象类的成员变量用的

 * 给成员变量赋值的方式：1，通过get set,2,通过构造方法

 * abstract与final不能在一起修饰成员方法：因为，final修饰的成员方法

 * 不能重写。

 * abstract 与static不能在一起修饰成员方法：因为，static修饰的成员是

 * 方法是随着类的加载而加载，执行。

3，猫类型，继承自动物类Animal,并且实现抽象方法eat()

 * */

//The type Cat must implementthe inherited abstract method Animal.eat()

//抽线类的子类，只有2个选择：要么还是抽象类，要么是非抽象类，必须实现所有的抽象方法

4，//因为不能实例化抽象类，也就是不能直接创建对象

     //Animal animal=new Animl();

     //既然不能直接实例化抽象类，那么抽象类主要是为了让子类继承用的，主要用于多态场合下

     /*

      * 多态的3个条件：有继承关系

      * 方法重写

      * 父类引用指向子类对象

5，//抽象类多态

     //左边是抽象类，右边是子类对象

     Animal animal=new Cat();

     //多态情况下，调用成员方法。编译的时候看左边，运行的时候看右边

     //在多态情况下，如何访问子类的特有方法呢

     //默认多态情况下，是无法通过父类引用，访问子类特有的方法

     //必须通过向下类型的转换

     //animal.method();

     Cat c=(Cat)animal;

     c.method1();//向下类型转化，调用子类特有的方法

     System.out.println(animal.i);

     //通过子类的构造方法，来初始化父类的成员变量

     Catc1=new Cat("Cat1","white",3);

6，定义了一个接口，有生命力的生物

 * 接口表示抽象的抽象

 * 接口中不能存在非抽象方法

 * 接口中可以有成员变量

 * 接口中不允许有构造方法，没法通过构造方法赋值，所以直接赋值例如：final static int

a=10;

 * 成员变量只能是常量

 * jdk1.8之前，接口里面的成员方法只能是抽象方法

 * */

7，  void act();//接口中可以存在成员方法

   //等同于public abstract void act();

8，//接口自定义另外一个动物接口。

//接口不能实现两外一个接口，但可以继承另一个接口

9，接口使用关键字interface来表示

 * 格式：public interface 接口名{}

 * 接口不能实例化，但接口可以被子类实现(implements)

 * 格式：

 *public class 子类implements接口名{}

10,Java a=(Java) student;//向下类型转换，用于调用子类特有的方法

11,如这种形式，爷（可以是接口）-父（可以是抽象类）-子（可以是子类），这种耦合度太高，可以灵活一下。抽象类是父类，接口跟父类的子类有关系，子类同时继承父类（抽象类），也同时继承接口，这样可以灵活点。

12，返回值类型为引用类型或者是抽象类

   //返回值类型为抽象类的方法，本质上返回的是该抽象类的子类对象

例如：

   public Animal method5(){

     returnnew Cat();//返回匿名对象

    

   }

同理

返回值类型为接口的方法，本质上返回的是实现了该接口的子类对象

例如：

public Ilife method6(){//返回值类型为接口类型

    

     return  new Cat();

   }

13，//抽象类作为方法的形式参数

   //传递的实参为：继承了该类的子类对象

   publicstaticvoid method7(Animal animal){

     animal.eat();

    

   }

调用：

method7(new Cat());

同理，接口一样

publicstaticvoid method9(Ilife life){

     life.act();

   }

14，如果形式参数为子类类型，例如Cat类型

   publicstaticvoid method8(Cat cat){

     System.out.println();

   }

但是，这个参数只能传这个子类型，而不能是其他子类型。而参数类型是父类的就不一样了，参数不仅可以传父类，也可以传该父类的其他子类。

15,书写规范。声明接口，用I标识，例如接口名：Iife

16.链式编程，

17，包；

(1)了避免类型重名的情况，而采用的一种管理方式。一个包名，就对应了文件系统的一个文件夹。

(2)名，使用.连接，对应了文件系统中的多级文件夹。

(3)建议都用小写字母，并且不能使用关键字作为包名

(4)则：

跨包访问的时候，需要使用import关键字，（Scanner类在java.util.Scanner

java.lang包下的所用类型，jvm启动的时候，默认会加载，表示，我们作为使用者，不再需要不需要手动导入java.lang包下面，直接使用即可。

(5)全类名。例如Scanner的形式

java.util.Scanner sc=newjava.util.Scanner(System.in);

（注意只能用一次，什么时候再用，什么时候写）

18，顺序问题

19，权限修饰符

（1）默认的default（只要在同一个包就行）

访问规则：A:在本类中可以用

B:同一个包的不同类型之间，可以访问，default方法。

C:同一个包的子类之间，（子类继承了父类的非私有方法，）可以访问。

D:跨了包下，不能访问默认(default)修饰的成员方法。

(2)protected修饰的:

A:在同一个类中，可以访问

B:在同一个包下面，不同类型之间，可以访问protected修饰的成员方法。

C:在同一个包下，子类可以访问父类protected修饰的成员方法。

D:不同包的子类，在子类本身中可以访问跨包的父类protected修饰的成员方法（因为子类继承父类的所有非私有的成员方法）

E:不同包的不同类，是不可以访问protected修饰的成员方法的。无论通过父类的引用，还是子类的引用都是不行的。

20，典型例题：

例一：.

public class Something {

  void doSomething () {

      private String s = "";

      int l = s.length();

   }

}这样写是不对的，因为，局部变量i，的生命周期是这个成员方法doSomething()方法。这个方法被调用完，s也就随之消失了。所以，修饰s的修饰符只有final是可以的。

例二：此处，Something类的文件名叫OtherThing.java

class Something {

   private static void main(String[] something_to_do) {       

       System.out.println("Do something ...");

    }

}

只有一个Something类存在，没有其他类型存在

这样写是错的。错误原因：main()的修饰符固定的只能是public，不能用private。

请记住：在一个类文件中，可以存在多个整型的定义（包括类和接口）但是，在一个类文件中，只能有一个public类型，并且该类型需与文件名保持一致。也就是说，没有public修饰类的时候，类名可以不与文件名一样。

例三：

interface Playable {

   void play();

}

interface Bounceable {

   void play();

}

interface Rollable extends Playable,Bounceable {

 

Ballball = new Ball("PingPang");

//在接口里，只能有成员变量（只能是常量），成员方法

上面这条语句，实际上是等同于=

Public static final Ball ball=new Ball(“PingPang”);

也就是ball=PingPang

   

}

class Ball implements Rollable {

   private String name;

   public String getName() {

       return name;

    }

   public Ball(String name) {

       this.name = name;       

    }

  public void play() {

      

       ball = new Ball("Football");

     //这样写是有错误的，因为在接口Rollable里面，ball已经被常量化了，所以，他不能再被赋值。

 

System.out.println(ball.getName());

 }

}

这样写是错误的。

错误原因：文本中添加