Day11-抽象类、接口、参数、包、权限修饰符-2019-04-05

抽象类

概念：不想被具体实例化的类，就叫做抽象类，用static修饰。同理有抽象方法。
     （有抽象方法就一定是抽象类，抽象类不一定有抽象方法）
格式：
    abstract class 类名 {}
    abstract 方法名()
特点：
    a.抽象类不能实例化
    b.只能由具体的子类实例化（多态的一种，抽象类多态）
    c.抽象类的子类
          要么是抽象类
          要么重写抽象类中所有的抽象方法

成员特点：
    a.成员变量
          可以是变量，也可以是常量
    b.构造方法
          有构造方法，但是不能实例化( 构造方法的作用是什么呢 ? 用于子类访问父类数据的初始化)
    c.成员方法
      (1) 抽象方法
          限制非抽象的子类必须重写这些抽象方法。(标准)       
      (2) 非抽象方法
          提供一个默认实现。(父类提供一个默认的行为)

注意事项：
    一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
        可以。防止它进行直接实例化

    abstract不能和哪些关键字共存
        private：abstract修饰的方法必须被子类重写, private修饰的方法不能子类继承。
        final：final修饰的方法不能被重写，abstract修饰的方法必须被子类重写。
        static：static修饰的方法，能够直接被类调用, 抽象方法没有实现。

---

接口

概念：
     代表的是扩展的功能 (USB上的接口)
     接口格式： interface 接口名 { }
     类实现接口： class 类名 implements 接口名 { }
特点：
     接口不能实例化，只能通过具体子类实例化，即接口多态。
     哪个类实现了接口，这个类即使该接口的子类。
     接口的子类：
        抽象类：不必重写所有的抽象方法。
        具体类：必须重写接口所有的抽象方法.
    
        往往以后定义标准会用接口，而不用抽象类
        接口弥补Java单继承的局限性。
成员变量
    全是public final
    
构造方法
    没有构造方法

成员方法
    抽象方法：默认用public abstract修饰.
    
    JDK1.8之前：只能是抽象方法
    JDK1.8后：
        a. 默认方法：如果该接口的子类没有重写该方法，就是这个默认行为。
            default void method() {}; // default表示的是默认方法，不是访问权限
            默认用public去修饰
            
        b. 静态方法：static void function() {};  
接口中所有的成员的访问权限都是public, 接口表示一个功能，所以谁都可以实现它。


类和类， 类和接口，接口和接口的关系
    类与类，类与接口，接口与接口的关系

    类与类：继承关系，只能单继承，但是可以多层继承

    类与接口：实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口

    接口与接口：继承关系, 可以单继承，也可以多继承

---

抽象类与接口的区别：

成员区别
    变量：
        抽象类: 变量，可以是常量
        接口：常量, 默认用pulic static final
    方法：
        抽象类：抽象方法，普通方法，静态方法
        接口：
            JDK1.8之前只能是抽象方法
            JDK1.8之后可以有默认方法(default), 可以有静态方法噶
    构造方法：
        抽象类：有构造方法
        接口：没有
    
    关系区别
        类与类 继承，单继承
        类与接口 实现，多实现
        接口与接口 继承，多继承
    
    设计理念区别
        抽象类 继承  体现的是：" is a "的关系。   共性功能
        接口 实现   体现的是：" like a "的关系。  扩展功能

---

参数

形式参数
    类：需要的是该类或者该类子类的对象
           如果参数是一个类名，那么实际需要的是一个具体的对象
    抽象类：需要的是该抽象类的子类对象
    接口：需要的是接口的子类对象
返回值类型：
    类：其实返回的是该类或者该类子类的对象
    抽象类：其实返回的是该类的子类对象
    接口：其实返回的是该接口的子类对象
            new StudentDemo().getStudent().show();
            链式编程  设计模式

---

包

增删改查(CRUD)
C: create
R: retrieve
U：update
D: delete

包：
    相当于文件夹，解决了类的命名冲突问题;
    对类进行分类管理
    通常按功能分类、按模块分类

定义包的格式
    package 包名;
注意事项：
    package语句必须是程序的第一条可执行的代码
    package语句在一个java文件中只能有一个
    如果没有package，默认表示无包名     
    
手动式
    a:javac编译当前类文件。
    b:手动建立包对应的文件夹。
    c:把a步骤的class文件放到b步骤的最终文件夹下。
    d:通过java命令执行。注意了：需要带包名称的执行
        java cn.itcast.HelloWorld

自动式
    a:javac编译的时候带上-d即可
        javac -d . HelloWorld.java
    b:通过java命令执行。和手动式一样

类的全限定名：包名.类名; 

导包：
    格式：import 包名.类名; 
    
    注意事项：
        必须导到类的那一级;
        虽然可以最后写*，但是不建议(如果是*的话，就会把该包下所有类都导入)
    
JDk1.5提供静态导入(不推荐大家使用静态导入)
    格式：import static 包名.类名.方法名;
    注意事项：
        必须导入到方法那一级;
        并且该方法必须是静态方法;
        
package,import,class有没有顺序关系(面试题)
    package > import > class
    最多1条       多个       多个
    
推荐：一个文件里面只写一个类;

---

权限修饰符

面向对象的程序设计：
    a. 有哪些类
    b. 每一类中有哪些职责
    c. 类与类之间的关系：
        类与类之间是怎么协作的
        类与类之间怎么访问

                        public  protected    默认  private
同一类中                 Y          Y         Y     Y
同一包子类,其他类         Y          Y         Y        
不同包子类               Y          Y(只能子类去访问)               
不同包其他类      

类及其组成可以用的修饰符:
    权限修饰符：  public, protected, 默认, private
    状态修饰符：  final, static
    抽象修饰符：  abstract
    
    protected, private, static 只能修饰成员
    
类：
    public, 默认, final, abstract
    我们自己定义：public居多

成员变量：
    四种权限修饰符均可,final,static
    我们自己定义：private居多

构造方法：
    四种权限修饰符均可,其他不可
    我们自己定义：public 居多

成员方法：
    四种权限修饰符均可，final,static,abstract
    我们自己定义：public居多