java值面向对象2

6.8 static关键字

1.静态变量

我们通常是这样定义一个静态变量：

static int a ;

我们定义了一个静态变量，静态变量他有什么作用呢？比如我们需要喝水，我们就去饮水机接水，饮水机就相当于一个静态变量，你同桌去喝水，还可以去饮水机接水，你把水接完了饮水机还在，你同桌把水接完了饮水机也还在，所以静态变量是共有的变量，如果我们有固定的数据时，每创建一个对象就需要创建一个这个变量，当创建对象特别多的时候，内存的占用越来越大，所以用static修饰这个变量，这个变量就只被创建一次，而且所有的对象都可以访问。换句话说，静态变量在对象被创建之前就存在，在对象消失之后还存在。生命周期比对象长。

静态变量在创建的时候也有初始化值。

静态函数不能用this关键字。 

2.静态函数

我们通常是这样定义一个静态函数的：

public static void Test{
    
}

静态函数又是什么？静态函数并不是对象的共有行为。静态函数的调用可以不创建对象直接调用，由于我们没有创建对象，所以没有初始化静态函数所在类的成员变量，我们就无法调用这个类中的成员变量。所以当一个函数不访问这个类里面的其他成员变量的时候，这个函数就可以被定义为静态函数。调用的时候也可以直接调用。这里我们需要注意：静态函数只能访问静态变量，不能访问非静态变量。因为我们知道，静态变量的存在周期在对象被创建之前，死亡在对象被创建之后，所以静态变量无论什么时候都可以被访问到，相当于全局变量，创建对象的时候也没有创建这个静态变量，所以我们在调用静态函数的时候，只能访问静态变量，因为他本来就存在，成员变来那个本来就不存在。

3.为什么主函数是静态的呢？

因为主函数要优先于其他函数运行，主函数如果不是静态的，就需要创建主函数对象才能运行主函数，那么主函数既然不是第一个执行的，主函数之前又没有其他执行的代码，那么没有代码待创建主函数的对象，所以我们的主函数必须为静态。

4.类的分类

1.实体类

实体类，比如一个人，一个动物，一棵树，他们一般只被加载一次

6.9 对象的内存图解

我们的javac命令将Java代码进行编译，生成了.class字节码文件，java将字节码文件加载进Java虚拟机中，开始运行程序，方法去分为静态方法区和非静态方法区，所有的非静态内容（二进制）被加载进非静态啊方法区，所有的静态内容（二进制）被加载进静态方法区。java虚拟机然后根据字节码文件名，也就是我们的类名在静态区去找主函数，然后开始运行程序。

6.10 静态变量与成员变量的区别

    1.生命周期
        成员变量随着对象的创建而创建 随着对象的消亡而消亡
        静态变量随着类的加载而创建 随着程序结束而消失
    2.调用方式
        成员变量必须先创建对象 在通过对象去调用
        静态变量可以被对象调用 也可以直接用类调用
    3.存储位置
        成员变量存在于堆内存中对象的所属空间里
        静态变量存在于静态方法区中类的所属空间里
    4.命名
        成员变量-对象的特有属性
        静态变量-对象的共有属性 类成员

6.11 代码块

1.代码块

{}

单纯的大括号称之为代码块。

2.局部代码块

for(){...} if(){...}

3.构造代码块：直接在类中出现的{...}

     当对象创建一次 构造代码块执行一次，作用等同于构造函数。

6.12单例模式

设计模式就是我们的前辈们总结出来的一些编码技巧，它并不是随着Java的诞生而诞生的，它是由Java的广大使用者总结出来的一套编码经验，常见有26种设计模式。

单例模式：使用场景是 某一个类只能创建一个对象

1.既然只能创建一个对象的话 就得不能让外界去创建对象，限制使用new不现实，只能从对象的创建流程中考虑 只要有一个步骤不行 对象就创建不出来，开辟空间分配地址 是由计算机底层决定 我们也控制不了， 构造函数执行  只需要将构造函数私有化即可
2.既然外界不能创建对象 我们还得保证对象的创建，所以我们只能在类内部创建对象，Single s=new Single();，能否写成 成员变量的形式？，所以private static。
3.内部创建出对象 还得向外界提供，因为private 外界不能直接访问，所以间接向外界提供一个函数 外界通过调用函数获取对象。

6.13继承

我们在写几个类的时候，有时候这个几个类会有相同的属性和行为，所以我们就可以把这些相同的属性和行为单独成为一个类，其他类继承这个类的属性和行为，在其他类中就不用写这些属性和行为了。我们用extends关键字来继承父类。java的类与类之间只能是单继承关系，一个父类可以有多个子类，但是一个子类只能拥有一个父类。

在java中所有类的最终的父类是Object!

 我们在一个函数继承于另一个函数的时候，子父类中成员变量/静态变量的特点：如果只有子类有且非私有，那么就调用子类的
，如果只有父类有且非私有，那么就调用父类的，如果子父类都有且非私有 那么就调用子类的，(成员变量之间 是不存在重写关系的!!!)。

调用顺序：子类对象成员->子类静态->父类成员->父类静态

我们在运行子类构造函数的时候，会默认执行super()；函数，来运行父类的构造函数，因为我们子类需要用到父类的变量或者函数，所在super必须在子类构造函数执行之前执行。

注意：super来调用父类的构造函数不代表就创建了父类的对象，只是父类空间的引用。 

如果在调用子类构造函数的时候传递了参数，我们需要自己去用super(...)去调用父类的构造函数。

子父类中成员函数的特点：
1. 如果只有子类有且非私有 那么就调用子类。
2.如果只有父类有且非私有 那么就调用父类的。
3.如果子父类都有且非私有 那么就调用子类的（函数重写） 

 函数重写是在子父类中，同名函数， 函数有什么组成：函数声明(权限 类型 返回值类型 函数名 参数列表)+函数体({}里面的内容)
重写的意义在于哪？在于子类继承了父类的函数声明(功能)，但是子类可以将该函数的具体实现进行优化或更改。

我们在函数重写中需要注意到的细节：

1.函数重名，但是参数列表不同，不构成重写关系。

2.函数重名，参数列表相同，返回值也相同，才构成重写关系。

3.子类重写父类的函数的时候，它的权限必须>=父类的权限。

4.如果父类的权限为private，子类本来就用不到，也不叫重写。

6.14抽象类

抽象类：模糊不清的类 不具体的类，当我们在抽取一个父类的时候，发现子类当中的一些共同方法在父类中无法进行具体的实现
，并且这些方法只能在子类中具体实现时，父类当中的这些函数就只保留函数声明即可，不必写函数体，那么此时这个函数就是 抽象函数！ 有抽象函数的类 就是抽象类。我们用abstract关键字修饰抽象类。

抽象类一定是父类！并且抽象类不能创建对象。

我们需要注意抽象类里面不能包含private和static关键字，因为我们的抽象类的函数需要被下面的类调用，所以不能私有化。 

6.16 多态

多态意思一个东西可以扮演多种角色。比如：小红是女孩，他也是人，她也是动物。小红可以是动物，但是他在当动物的时候必须表现出动物应该有的样子，意思就是必有有一个类是冒，一个类是狗，一个类是动物，猫和狗都属于动物，我们将他们继承于动物，在创建他们的时候可以直接Animal a=new Dog();Animal a=new Cat();我们在喂养他们的时候，可以直接传入参数Animal，他会自动判断这个动物是什么来调用相应的函数。

在这里我们需要注意如果子类中没有重写，并且父类中有，就调用父类的，如果子类中有重写，父类也有，就调用子类的，如果子类中没有重写，父类中也没有这个函数，就会报错。

我们用a instanceof pig这个语句来判断a是不是猪，然后进行猪专有的动作。

class DuoTaiDemo02{
    public static void main(String[] args){
        Dog d=new Dog();
        Cat c=new Cat();
        Pig p=new Pig();
        feed(d);
        feed(c);
        feed(p);
    }
    //Animal a=new Dog();
    //Animal a=new Cat(); 向上类型转换
    public static void feed(Animal a){
        a.eat();
        //ClassCastException 类型转换异常
        //判断对象的本质类型 instanceOf
        if(a instanceof Pig){
            Pig pp=(Pig)a;
            pp.gongBaiCai();
        }
    }
    /*
    public static void feed(Pig p){
        p.eat();
    }
    public static void feed(Cat c){
        c.eat();
    }
    public static void feed(Dog d){
        d.eat();
    }
    */
}
abstract class Animal{
    static abstract void eat();
    abstract void jiao();
}
class Pig extends Animal{
    void eat(){
        System.out.println("猪啥都吃......");
    }
    void jiao(){
        System.out.println("猪哼哼哼......");
    }
    void gongBaiCai(){
        System.out.println("猪拱白菜......");
    }
}
class Dog extends Animal{
    void eat(){
        System.out.println("狗吃狗粮......");
    }
    void jiao(){
        System.out.println("狗汪汪汪......");
    }
    void lookDoor(){
        System.out.println("狗看家~......");
    }
}
class Cat extends Animal{
    void eat(){
        System.out.println("猫吃鱼......");
    }
    void jiao(){
        System.out.println("猫喵喵喵......");
    }
    void catchMouse(){
        System.out.println("猫捉老鼠~......");
    }
}