static关键字

（1）如果没有static会怎样？

• 定义Person类

  • 姓名、年龄、国籍，说话行为
  • 多个构造，重载形式体现

• 中国人的国籍都是确定的

  • 国籍可以进行显示初始化

class Person {
    String name;
    int age;
    String gender;
    String country = "CN";
    Person() {}

Person(String name, int age, String gender, String country) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.country = country;
    }

    void speak() {
        System.out.println("国籍:" + country + " 姓名：" + name + " 性别：" + gender + " 年龄：" + age + " 哈哈！！！");
    }}

(2)new Person 对象

• 分析内存
• 每个对象都维护实例变量国籍也是。

• (3)内存分析

  • 栈，堆、共享区

  • Demo.class加载近共享区

  • Demo类的main方法进栈
    Person p1=new Person();

  • Person.class 加载进方法区

    • 堆内存开辟空间，实例变量进行默认初始化，显示初始化。
      内存地址传给变量p1，栈和堆建立连接
      person p2=new Person();
    • 堆内存开辟空间，实例变量进行默认初始化，显示初始化。
      内存地址传给变量p2，栈和堆建立连接

问题1：为了让所有Person对象都共享一个country ，可以尝试将country放入共享区。

问题2：country变量如何放入共享区？对象如何访问？

方案一：使用static

• 2：static
  1：为了实现对象之间重复属性的数据共享

• 3：static使用
  1：主要用于修饰类的成员
  1：成员变量
  1：非静态成员变量：需要创建对象来访问
  2：静态成员变量：使用类名直接调用，也可以通过对象访问

方案二：成员方法
可以使用类名直接调用

• 静态函数：
  1：静态函数中不能访问非静态成员变量，只能访问静态变量。
  2：静态方法不可以定义this,super关键字.
  3：因为静态优先于对象存在.静态方法中更不可以出现this
  非静态函数：非静态函数中可以访问静态成员变量

细节：
1：静态函数中不能使用非静态变量
2：非静态函数可以访问静态变量

问题3：为什么静态函数中不能访问非静态成员

    1：static修饰的成员在共享区中。优先于对象存在
    2：验证
        1：使用静态代码块验证
            1：静态代码块
                static{
                    静态代码块执行语句;
                }
             1：静态代码块特点

随着类的加载而加载。只执行一次，优先于主函数。用于给类进行初始化。

总结：
static特点

• 随着类的加载而加载，静态会随着类的加载而加载，随着类的消失而消失。说明它的生命周期很长。
• 优先于对象存在。-->静态是先存在，对象是后存在。
• 被所有实例(对象)所共享。
• 可以直接被类名调用
  5：静态变量（类变量）和实例变量的区别:
  1存放位置
  1：类变量随着类的加载而加载存在于方法区中.
  2：实例变量随着对象的建立而存在于堆内存中.
  2生命周期
  1：类变量生命周期最长,随着类的消失而消失.
  2：实例变量生命周期随着对象的消失而消失.

静态优缺点

• 优点:对对象的共享数据进行单独空间的存储,节省空间 例如Person 都有
  国籍。该数据可以共享可以被类名调
• 缺点：生命周期过长
  • 访问出现局限性。（静态只能访问静态）

问题4：什么时候定义静态变量

• 静态变量（类变量）当对象中出现共享数据
• 例如：学生的学校名称。学校名称可以共享，对象的数据要定义为非静态的存放在对内存中（学生的姓名，学生的年龄）

问题5：什么时候定义静态函数

• 如果功能内部没有访问到非静态数据（对象的特有数据。那么该功能就可以定义为静态）

静态的应用：自定义数组工具类

main方法详解

主函数是静态的
```public static void main(String[] args){
}

主函数是什么：主函数是一个特殊的函数，作为程序的入口，可以被jvm识别。
- 主函数的定义：
           public ：代表该函数的访问权限是最大的。
           static ：代表主函数随着类的加载，就已经存在了。
           void：  主函数没有具体的返回值
           main ： 不是关键字，是一个特殊的单词可以被jvm识别。
           (String[] args) 函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。
           主函数的格式是固定的：jvm能够识别
           jvm在调用函数是，传入的是new String[0];
可以在dos窗口中执行 java  Demo5   hello  world   给类Demo5的main方法传递2个参数，参数与参数之间通过空格隔开。



#####单例设计模式：一些人总结出来用来解决特定问题的固定的解决方案。
解决一个类在内存中只存在一个对象，想要保证对象的唯一。
1 为了避免其他程序过多的建立该类对象。禁止其他程序建立该类对象。
2 为了其他程序可以访问该类对象，在本类中自定义一个对象。
3 方便其他程序对自定义类的对象的访问，对外提供一些访问方式。
 代码：
1将构造函数私有化
2在类中创建一个私有的本类对象
3提供一个用类名调用的公有方法获取该对象。

####继承
类和类之间的常见关系。
-  既然继承是描述类和类之间的关系，就需要先来了解类和类之间的常见关系
现实生活的整体与部分
*举例说明*

    - 1：学生   是人  
    - 2：狗     是动物
    - 3：球队 包含 球员 整体与部分的关系，部分可以删除和增加
    - 4：笔记本包含 cpu 整体与部分的关系，部分不可以删除和增加
    - 5：航母编队 包含（航母 护卫舰 驱逐舰 舰载机 核潜艇）

**java中的类与类关系
java中的类关系
1：is a 关系 (学生是人)
2：has a 整体与部分
**
    

####继承
- 1：描述一个学生类
  - 1：姓名年龄学号属性，学习的方法
- 2：描述一个工人类
 - 1：姓名年龄工号属性，工作的方法
- 3：描述一个人类
  - 1：姓名年龄属性，说话的方法。
- 4：发现学生类和人类天生有着联系，学生和工人都是人。所以人有的属性和行为学生和工人都会有。出现类代码重复

*问题:*
- 1：如果没有继承,出现类和类的关系无法描述
- 2：如果没有继承，类和类之间有关系会出现类和类的描述代码的重复

*继承特点*
- 1：描述类和类之间的关系
-  2：降低类和类之间的重复代码
- 3：降低对象和对象之间的代码重复使用静态变量
- 4：降低类和类之间的代码重复使用就继承
    
##extends关键字
**[1]、继承使用extends关键字实现**
- 1：发现学生是人，工人是人。显然属于is a 的关系，is a就是继承。
- 2：谁继承谁？
    - 学生继承人，发现学生里的成员变量，姓名和年龄，人里边也都进行了定义。有重  复代码将学生类的重复代码注释掉，创建学生类对象，仍然可以获取到注释的成员。这就是因为继承的关系，学生类（子类）继承了人类（父类）的部分


**[2]、继承细节；**   
- 类名的设定，被继承的类称之为父类(基类)，继承的类称之为子类
    - 2：子类并不能继承父类中所有的成员

- 父类定义完整的成员 静态成员，非静态，构造方法。静态变量和静态方
法都可以通过子类名.父类静态成员的形式调用成功。
    - 2：所有的私有成员不能继承,private修饰的成员。
    - 3：构造函数不能被继承

- 如何使用继承
 - 不要为了使用继承而继承。工人和学生都有共性的成员，不要为了节省代
码，让工人继承学生。


##super关键字

- 定义Father(父类)类
    - 成员变量int x=1;
    - 构造方法无参的和有参的，有输出语句
- 定义Son类extends Father类
    - 成员变量int y=1;
    - 构造方法无参和有参的。有输出语句
    this.y=y+x;
- 创建Son类对象
        Son son=new Son(3);
        System.out.println(son.y); //4


- 子类对象为什么可以访问父类的成员。
        1：this.y=y+x;有一个隐式的super super.x

**super关键字作用**
- 主要存在于子类方法中，用于指向子类对象中父类对象。
- 访问父类的属性
- 访问父类的函数
- 访问父类的构造函数

**super注意**
- this和super很像，this指向的是当前对象的调用，super指向的是当前调用对象的父类。Demo类被加载，执行main方法，Son.class加载，发现有父类Father类，于是Father类也加载进内存。类加载完毕，创建对象，父类的构造方法会被调用（默认自动无参），然后执行子类相应构造创建了一个子类对象，该子类对象还包含了一个父类对象。该父类对象在子类对象内部。this super只能在有对象的前提下使用，不能在静态上下文使用。
- 子类的构造函数默认第一行会默认调用父类无参的构造函数，隐式语句
super();
    - 父类无参构造函数不存在，编译报错。
   
- 子类显式调用父类构造函数
在子类构造函数第一行通过super关键字调用父类任何构造函数。如果显式调用父类构造函数，编译器自动添加的调用父类无参数的构造就消失。构造函数间的调用只能放在第一行，只能调用一次。super() 和this()不能同时存在构造函数第一行。




**super思考**
如果开发者自定义了一个类，没有显示的进行类的继承，那么该类中成员函数是否可以使用super关健健字？可以使用，继承了Object类，Object类是所有类的父类。

    
##重写（Override）
**在继承中，子类可以定义和父类相同的名称且参数列表一致的函数，将这种函数
称之为函数的重写.**
- 定义Father类
  - 姓名，吃饭方法，吃窝窝头。
    - 定义Son类，继承Father
        - Son类中不定义任何成员，子类创建对象，仍然可以调用吃饭的方法。
        - 父类的吃饭的方法，Son不愿吃。Son自己定义了吃饭的方法。

*此时父类中有一个吃饭的方法，子类中有2个吃饭的方法，一模一样，只是方法体不一样。*
*一个类中两个函数一模一样，是不允许的。*
(1)编译运行，执行了子类的方法。
(2)使用父类的方法，在子类方法中，使用super.父类方法名。


**前提**:
必须要有继承关系

**特点**
- 当子类重写了父类的函数，那么子类的对象如果调用该函数，一定调用的是重写过后的函数。可以通过super关键字进行父类的重写函数的调用。
- 继承可以使得子类增强父类的方法

**细节**
- 函数名必须相同
- 参数列表必须相同
- 子类重写父类的函数的时候，函数的访问权限必须大于等于父类的函数的访
问权限否则编译报错
- 子类重写父类的函数的时候，返回值类型必须是父类函数的返回值类型或该返回值类型的子类。不能返回比父类更大的数据类型： 如子类函数返回值类型是Object

        1：定义 A B  C 类 B extends A  
        2：Father类中定义A getA();
        3：Son 类中重写getA(); 方法，尝试将返回值修改为B，C ,Object
            1：B编译通过
            2：C 编译失败 ,没有继承关系
            3：Object编译失败,比父类的返回值类型更大


- 子类对象查找属性或方法时的顺序：
    - 原则：就近原则。
如果子类的对象调用方法，默认先使用this进行查找，如果当前对象没有找到属性或方法，找当前对象中维护的super关键字指向的对象，如果还没有找到编译报错，找到直接调用。
- 重载和重写的不同
    - 重载(overload)：  
        所有的重载函数必须在同一个类中 
        - 特点： 
            函数名相同，参数列表不同，与其他的无关(访问控制符、返回值类型)
     - 不同：
            个数不同 、 顺序不同、 类型不同 
  -   重写(override)：
         1：前提： 继承
        2：特点：
              函数名必须相同、参数列表必须相同。
              子类的返回值类型要等于或者小于父类的返回值

##instanceof 关键字

  *instanceof是什么？*
  - 属于比较运算符：
 - instanceof关键字：该关键字用来判断一个对象是否是指定类的对象。
 - 用法：对象  instanceof 类;   
      该表达式是一个比较运算符，返回的结果是boolea类型  true|false
    **注意：使用instanceof关键字做判断时，两个类之间必须有关系。**

show me code
定义一个功能表函数，根据传递进来的对象的做不同的事情，如果是狗让其看家，如果是猫让其抓老鼠
        1：定义动物类
        2：定义狗类继承动物类
        3：定义猫类继承动物类
        4：定义功能根据传入的动物，执行具体的功能

**instanceof好处
            可以判断对象是否是某一个类的实例    **


##final关键字

需求： 
1：定义静态方法求圆的面积
    2：定义静态方法求圆的周长
    3：发现方法中有重复的代码，就是PI，圆周率。
 -  如果需要提高计算精度，就需要修改每个方法中圆周率。
    
4：描述一个变量
  - 方法都是静态的，静态只能访问静态，所以变量也定义为静态的。
<code>public static double PI=3.14;</code>
  - 如果定义为public后，新的问题，类名.PI=300; 改变了PI的值。
  - 修改为private，修改为private后进行了封装，需要getset公共访问方法。
3）现有的知识不能解决这样的问题了。可以使用final

**使用final**
- final关键字主要用于修饰类、类成员、方法、以及方法的形参。
- final修饰成员属性：

            1：说明该成员属性是常量，不能被修改。
                public static final double PI=3.14;
                1：public ：访问权限最大
                2：static ：内存中只有一份
                3：final  ：是一个常量
                4：常量名大写
                5：必须初赋值。

            2：使用类名.成员。修改该成员的值，报错。--常量不能被修改
                1：基本数据类型，final使值不变
- 对象引用，final使其引用恒定不变，无法让其指向一个新的对象，但是对象自身却可以被修改。
                3：该关键字一般和static关键字结合使用
                    1：常量可以优先加载，不必等到创建对象的时候再初始化。
                4：final和static可以互换位置
                5：常量一般被修饰为final
            3：fianl修饰类：
                1：该类是最终类，不能被继承。
                    1：将父类加final修饰，子类继承，就会报错。
*查看api文档发现String类是final的。Integer类也是final的*
                    1：为了防止代码功能被重写
                    2：该类没有必要进行扩展
            4：final修饰方法：
                1：该方法是最终方法，不能被重写
- 当一个类被继承，那么所有的非私有函数都将被继承，如果函数不想被子类继承并重写可以将该函数final修饰   
                3：当一个类中的函数都被修饰为final时，可以将类定义为final的。


            5：final关键字修饰形参
                1：当形参被修饰为final,那么该形参所属的方法中不能被篡改。
- 项目中主要用于一些只用来遍历未知数据的函数。将未知变量声明为final的。增强数据的安全性。


**思考**
- 为什么子类一定要访问父类的构造函数呢
1：子类继承了父类的属性，如果要使用父类的属性必须初始化，创建子类对象，必须先初始化父类属性,必须调用父类的构造方法。
  - 为什么调用父类无参的构造函数
设计java语言之时，只知道编译器会默认添加无参的构造函数，有参的无法确定,但是可以通过super关键字显式调用父类指定构造函数。
  - 为什么super()this()语句要放在构造函数的第一行
子类可能会用到父类的属性，所以必须先初始化父类。
- 静态和非静态的区别。说一下内存。
- 成员变量和静态变量的区别？
- 静态的特点以及注意事项？
- 什么时候使用静态？
- 继承的好处？
- java改良多继承的原因？
- 当使用一个已存在的继承体系时，该如何更快应用 
- 什么时候用继承？
- super和this的特点？
- 覆盖的特点，何时应用，注意事项？
- 子类的实例化过程？为什么是这样的实例化过程？
- super语句，和this语句为什么不能同时存在，super为什么要定义在第一行？