day10-java中的关键字和多态

关于jaza中的static

1.static修饰的方法是静态方法

2.static修饰的变量是静态变量

4.所有static修饰的元素都是静态元素，都可以使用“类名.”的方式进行访问，当然也可以引用的方式访问【不建议】。

5.static修饰的所有元素都是类级别的特征和具体的对象无关。

静态变量在类加载的时候就初始化，不需要创建对象，内存就开辟了。储存在方法区内存当中。

在类中成员变量声明为实例变量时，所有对象都有这个属性，但是这个属性的值会随着对象的变化而变化【不同的对象这个具体的属性不同】

在类中成员变量声明为静态变量时，所有对象的这个属性值是一样的，直接使用“类名.属性名”的方式访问这个属性。

6.可以使用static关键字来定义“静态代码块”
语法格式：static{
                        java语句
}

静态代码块在类加载时执行，并且只加载一次

7.静态代码在一个类中可以编写多个，并且自上而下的顺序依次执行。

8.静态代码块的作用：eg：只要类加载在JVM之中，就加载到日志中

        静态代码块是为开发者准备的一个特殊的时刻（类加载时刻），所希望在此时加载一个固定的程序，可以放入静态代码块之中。

9.通常在静态代码块之中完成预备工作，比如：初始化连接池，解析XML配置文件

//【实例代码块】/

语法结构：{

}

在对象加载到堆内存，构造方法之前，加载实例代码块中的内容

//【实例代码块】/

类的继承：

1.继承是面向对象三大特征第一（封装，继承，多态）

2.继承的基本作用是：代码的复用，但是继承更重要的作用就是为了以后的方法的覆盖和多态的机制。

3.继承的语法格式：

【修饰符列表】class 类名 extends 父类名{
                类体 = 属性 + 方法
}

4.java语言当中的继承只支持单继承，一个类不能同时继承很多类，只能继承一个类，不想c++中的支持多继承。 

5.关于继承的一些术语：

        A类： 父类、基类、超类 superclass 

        B类：子类、原生类、派生类 subclass

6.继承类的数据： 私有的不支持继承，构造方法不支持继承，其他数据都可以被继承 

7.虽然java语言中只支持单继承，但是可以间接支持其他类

8.如果没有显示继承具体的类，所有的类都继承java中的object类。

java中的finial关键字：

方法的覆盖：

回顾java语言中的方法重载：

        1.方法重载又称为overload

        2.方法重载在同一个类中，方法的功能相似，建议方法名相同

        3.方法重载的条件：在同一个类中，方法名相同，参数列表不同

        4.方法重载和返回值类型无关，和修饰符列表无关。

关于java语言中方法的覆盖：

        1.方法覆盖又被称为方法重写，override/ overwrite

        2.方法重写的条件：当父类的方法已经无法满足我们当前子类的任务需求，子类有必要完成我们对于方法重新编写。这个重新编写的过程被我们称为方法覆盖/方法重写。 

        3.方法重写发生在具有继承关系的父类之间，方法名相同，返回值类型相同，形参相同。
           所以建议在方法重写的时候去复制粘贴。访问权限不能更低，可以更高。抛出异常不能更               多，可以更少。

        4.避免写错产生的方法出错，导致没有产生方法重写。

        5.注意：私有方法不能继承，所以不能覆盖。

                      构造方法不能继承，所以不能覆盖。

                      静态方法不存在覆盖。

                      覆盖只针对方法，不针对属性。

多态：

关于java语言中的多态机制：

        1.animal，cat，bird三个类之间的关系：

                cat和bird都继承animal，cat和bird没有任何关系。

        2.面向对象三大特征：封装、继承、多态。

        3.关于多态中涉及到的几个概念：【无论是向上转型还是向下转型，类之间必须有关系】

                *向上转型（upcasting）：子类向父类转型（自动类型转换）

                *向下转型（downcasting）：父类向子类转型（强制类型转换）【需要加强制类型转换符】

         以下是example从Cat类型转换为了Animal类型，从子类型转换为父类型，自动类型转换。

        //多态语法：
        Animal example = new Cat();

        System.out.println("this is duotai yufa moving");
        example.move();

        4.JAVA中允许父类型引用指向子类型对象。

 JVM的编译阶段，认为example是一个Animal类型，move方法在运行过程中，JVM会把它当做Cat类型。【上边程序在编译阶段的静态绑定就发生了错误，所以无法运行】

        java程序永远都分为编译阶段和运行阶段；

        先分析编译阶段，在分析运行阶段，编译无法通过，根本无法运行。

        字节码中有move（）方法，所以编译通过了，这个过程我们称之为静态绑定，编译阶段绑定。只有静态绑定成功了，才有后续的运行。

        在程序运行阶段，JVM堆内存当中真实创建的对象是Cat对象，那么调用move（）方法的时候，此时程序发生了动态绑定，运行阶段绑定。当move（）方法从Cat中注释掉之后，调用的仍然是Cat的move（）方法。无论Cat有没有move（）方法，调用的时候一定是Cat的move（）方法。

        假设想让example执行catchmouse方法，我们该如何转换呢？（向下转型，downcasting）

                当效用方法在子类型中特有的，在父类型中不存在，可以进行强制类型转换

public class duoTai_Test {
    public static void main(String[] args) {

        //多态语法：
        Animal cat2 = new Cat();
        cat2.move();


        Cat cat3 = (Cat) cat2;

        cat3.catchmouse();
    }
}

        5.父类型引用指向子类型对象这种机制导致程序在编译阶段绑定和运行阶段绑定两种不同的形态/状态，这种机制被称为多态语法机制。

        6.著名异常：

        //多态：
        Animal a3 = new Bird();

        Cat c3 = (Cat) a3;

   以上语法在编译的时候没有问题，因为是从父类转换为子类，向下转型，语法合格。程序虽然编译通过了，但是运行阶段会出现异常，因为JVM堆内存当中的真实对象是Bird类型，Bird类型无法转换为Cat类型，因为两种类型之间不存在任何继承关系，这就是JAVA中著名的异常：java.lang.ClassCastException。这种异常只有在向下转型的时候会发生异常。

1.以上异常只有在强制类型转换的时候会发生，也就是说“向下转型”存在隐患（编译过了，运行错了）

2.异常避免方法：使用instanceof 运算符，可以避免这样的异常。

        语法格式：（引用（instanceof）数据类型名）

        以上运算符的执行结果是布尔类型。结果可能是true/false 

3.关于运算结果：假设 a instanceof Animal 

        true：a这个引用指向的对象是一个animal

        false：a这个引用指向的对象不是一个animal

       所以JAVA在强制类型转换的时候，需要用instanceof 来判断后在进行强制类型转换。

        //多态：强制类型转换的判断
        Animal a3 = new Bird();
        boolean a = a3 instanceof Animal;
        System.out.println(a);

        if(a3 instanceof Cat){
            Cat c3 = (Cat) a3;
            a3.catchmouse();
        }else if (a3 instanceof Cat){
            Bird b3 = (Bird)a3;
            a3.move();
        }else{
            System.out.println("Class a3 = Animal");
        }

 多态在实际开发中的作用：

降低程序的耦合度，提高程序的拓展里，能使用多态尽量使用多态，面向抽象编程而不是拓展编程。

public class duotai2_Test {
    public static void main(String[] args) {
        Master_class master = new Master_class();

        Pet_class cat1 = new Cat();
        Pet_class dog1 = new dod_class();
        snake_class snake1 = new snake_class();

        master.feed(snake1);
        master.feed(cat1);
        master.feed(dog1);
    }
}

class Master_class {
    public static void main(String[] args) {

    }
    public void feed(Pet_class p){
        System.out.println("master is feeding");
        p.eat();
    }
}

class snake_class extends Pet_class{
    public void eat(){
        System.out.println("snake is eating");
    }
}

class Pet_class {

    String name;

    public void eat(){
        System.out.println(this.name+"pet is eating");
    }
}

class Cat extends Pet_class{
    String name;

    public void eat(){
        System.out.println(this.name+"is eating fish");
    }

}

class dod_class extends Pet_class {
    String name ;

    public void eat(){
        System.out.println(this.name+"is eating bone");
    }
}