java第五、六、七章

    第五章：抽象类与接口

抽象类：

    在编写一个类时候，往往会给它定义一些属性或方法，但是有的时候，某些方法只知道应该
    存在，但是不知道它如何实现，那么该类就是抽象类，这些不知道具体如何实现的方法就叫做抽象方法。   
    
    抽象类的抽象方法都是等待子类去继承然后子类去重写父类的抽象方法。
    

    抽象的关键字： abstract

    定义抽象类：  public  abstract class  {  }

    定义抽象方法：  public abtract 返回类型 方法名(参数列表);

    
    
    1.抽象类中可以没有抽象方法，可以有具体的方法。

    2.抽象方法只能存在于抽象类中。
    
    3.如果某子类继承了一个抽象类，那么该子类必需要重写父类的抽象方法。

    
    
*/

//Demo1就是一个普通的类
public class Demo1 {

    int age = 18;
    
    public void method1() {
        System.out.println("这是普通的方法");
    }
}

抽象类：需要子类去继承 然后重写

接口：

需要一个实现类去实现(implements)该接口。然后重写接口的相关方法。  
注意不是继承关系了  但是可以理解成继承关系。

继承：extends   实现：implements

此时这个Z2就是一个接口，而非一个类或抽象类
接口里面只能存在抽象方法，所以直接将public  abstract省略

public interface Z2 {

public abstract 返回类型 方法名(参数列表);
    
    void a1();//一般来说为了简化代码，都是直接这样写即可
    
    public abstract void a2();
    
    abstract void a3();
    
    public void a4();
    
    以上4个方法 其实都是

kage com.yyzy.test;

多态

    多态是继封装，继承之后的面向对象的第三个特征。

    简单来说：多态指的就是：对象的多种形态，一个对象在不同条件下所变现的不同形式。
    
    例如打印机：在黑白打印机情况下打出来为黑白，在彩色打印机情况下打印出来为彩色
    
    多态需要依赖于继承或接口实现才能体现多态。

多态语法：

    语法如下：
    父类或接口  变量名  =  new  子类或实现类( );

        创建一个父类Person，内部提供一个方法work，打印正在工作。
        内部提供一个成员变量name，值为人类。
        
        创建一个子类Teacher，内部提供一个方法work，打印正在授课。
        内部提供一个成员变量name，值为老师。
        
        利用多态的特性测试相关代码。

*/
public class Test1 {
    public static void main(String[] args) {
      Teacher t = new Teacher();
       Person p = new Person();
     System.out.println(t.name);

      t.work();
       System.out.println(p.name);
       p.work();
        //以上写法才是正常的写法。
        //以下写法是多态的写法：
        

        Person p = new Teacher();
        p.work();
        //总结1：成员变量都看=的左边。
        //总结2：成员方法编译看左边，运行看右边。   
        //运行看右边指的就是：调用的是右边的方法。
        //编译看左边指的就是：只能看到左边的对象的方法

类的高级特性

final

final表示最终的。用来修饰类，或方法，或属性，或对象。
        语法如下：
        修饰类： public  final  class Xxx{  }
        修饰方法：public final  返回类型 方法名(参数列表){}
        修饰属性：final  数据类型 变量名 = 属性值; 
        修饰对象：本质就是修饰一个变量名

        如果final修饰一个类，就表示该类是最终类。它无法被继承。
        如果final修饰一个方法，就表示该方法无法被子类重写
        如果final修饰一个属性，就表示该属性是一个最终属性，无法修改值。
        如果final修饰一个对象，该对象无法重新修改，但是内部属性可以修改。
        
        
        

    
    public static void main(String[] args) {
        final Demo2 d = new Demo2();
        d.age = 11;
        d.age = 22;
        System.out.println(d);
        
        
        
    }
    
    
    public void a() {
        
    }
    
    
}

static

static表示静态的。
        用来修饰方法或属性，可以不必通过实例化之后，再去调用相关的方法或属性。
        如果是在当前类下调用，直接通过方法名或属性名调用即可。
        如果是在不同类下调用，直接通过类名.方法名 或类名.属性名
        

        语法如下：

        修饰方法：

        权限修饰符  static   返回类型  方法名(参数列表) { 代码体; }

        
        修饰属性：

        权限修饰符 static  数据类型  变量名 ;
        
        
        适用场景：适用于公用的方法或属性。

        被static修饰的：
        随着类的加载而加载，且只会加载一次。
        被static修饰的变量或方法要优先级高于非static修饰的变量或方法。
        所以：static方法中无法调用非static方法或变量
        但是非static方法可以调用static方法或变量。
        
        通过static修饰的变量或方法，就不推荐通过实例化的形式来调用，因为随着类的加载而加载，多此一举了。

        
        
        
    */
    
    static int age  = 18;
    public static void a1() {
        
    }
    
    public void a2() {
        a1();
    }
    
    
    public static void main(String[] args) {
        Demo1 d = new Demo1();
        d.a1();
        
    }

代码块

代码块：分为三大类分别是：
        A.局部代码块：例如常见的类，方法都是通过{...} ，打大括号内部的就是局部代码块。
        B.构造代码块，一般放在类的内部，用{...}包起来。优先级高于构造方法
        C.静态代码块，一般放在类的内部，用static {...}包起来，优先级最高