java的知识点

1. 成员变量和局部变量的区别

• 在类中位值不同
  成员变量：类中方法外
  局部变量：方法定义总或者方法声明上
• 在内存中的位置不同
  成员变量：在堆中
  局部变量：在栈中
• 生命周期不同
  成员变量：随着对象的创建而存在，随着对象的消失而消失
  局部变量：随着方法的调用而创建，随着方法的调用完毕而消失。
  -初始化值不同
  成员变量：有默认值
  局部变量：没有默认值，必须定义，赋值，然后才能使用

2. static关键字的理解

• 静态的意思：可以修饰成员变量和成员方法。
• 静态的特点：
  1. 在静态方法中没有this对象
  2.优先于对象的存在。
  （static修饰的方法和成员变量，都是在类加载的时候，直接加到的内存当中的，而不是static修饰的方法或者成员变量是在创建对象的时候才开始加载到内存当中的）
  3.被类的所有的对象共存：
  也就是可以被任何对象使用或者修改，所有对象使用的都是同一块内存。
  4.可以通过类名调用：
  即可以使用对象名调用，也是可以使用类名调用，建议使用类名调用
• 静态的内存图：
  静态的内容存在方法去静态区
• 静态的注意事项：
  1。静态的方法中没有 this 对象
  2.静态只能访问静态。（静态方法只能访问静态方法）
• 静态变量和成员变量的区别
  1.所属不同：
  静态变量：属于类，类变量
  成员变量：属于对象，对象变量，实例变量
  2.内存地址不同：
  静态变量：方法去的静态区
  成员变量：堆内存
  3.声明周期不同：
  静态变量：静态变量是随着类的加载而加载，随着类的消失而消失
  成员变量：随着对象创建而存在，随着对象的消失而消失
  4.调用不同：
  静态变量：可以使用对象名调用，也可以使用类名调用
  成员变量：只能使用对象名调用

3.代码快：

• 使用{}括起来的代码。

• 分类：
  1.局部代码快：
  用于限定变量的声明周期，及早释放，提高内存的利用率。
  2.构造代码快：
  把多个构造方法中相同的代码放到这里，每个构造方法执行请，首先执行构造代码快
  3.静态代码块
  对类数据初始化，仅执行一次。

• 静态代码快，构造代码快，构造方法的调用顺序
  静态代码快>构造代码块>构造方法
  例子：

   class Person {
       static {
       System.out.println("Penson静态代码快");
    }
    {
        System.out.println("Penson构造代码块");
  
    }
    public Person (){
        System.out.println("Penson构造方法");
    }
    }
   class Student extends Person{
    static {
        System.out.println("Student静态代码快");
   }
   {
        System.out.println("Student构造代码块");
  
    }
    public Student (){
        System.out.println("Student构造方法");
   }
  
   }
   public class ExtendsDemo {
       public static void main(String[] args){
            Student stu = new Student();
   /*
    * 总结：
    * 1.当创建Student对象的时候，看到有父类Person，就去加载父类的class文件、加载class文件的同时会加载Person的静态代码快，加载完毕就接着加载Student的静态代码块。
    * 2.加载完毕class文件时，要去初始化加载父类的构造代码快和父类的构造方法，完毕后再去加载Stident的构造代码块和构造方法
    * 所以打印的结果如下：
   * Penson静态代码快
     Student静态代码快
     Penson构造代码块
     Penson构造方法
     Student构造代码块
     Student构造方法
    */
    }
    /*补充：类的加载过程：
       1.如果有静态方法或者静态的属性的时候，会随着类的加载而加载。
       2.如果有成员变量时，会默认初始化成员变量，在去显示初始化（int a = 10; 默认初始化时a = 0,显示初始化后才等于10。int long double float默认初始化复制都为0或者0.0，引用类型初始化时为null）
       3.再去构造方法。*/
  
   }
  

4.final关键字用法

1.可以修饰类：修饰的类不能被集成。
2.可以修饰方法：修饰的方法不能被重写。
3.可以修饰变量：修饰的变量是不可以被修改的。其实就是常量。（所以定义常量就是使用final来修饰）

注意事项：

1.修饰局部变量：
        a.基本数据类型：修饰的变量值是不可以改变的。
        b.引用类型：修饰的变量的内存地址值是不可以改变的，但是里面的属性值是可以改变的。

5.多态中成员反问的特点

        多态的表现形式：父类 变量名 = new 子类();
    A.成员变量：
        编译看左边，运行看左边。（编译看父类里面有没有这个变量，运行的时候反问的也是父类里面的变量）
    B.构造方法：
        子类的构造都会默认访问父类的构造
    C.成员方法：
        编译看左边,运行看右边。（编译看父类有没有这个成员方法，运行是反问子类里面的成员方法。`在多态里面，方法是可以重写的`）
    D.静态方法：
        编译看左边，运行看左边。

6.抽象类

• 抽象类的特点：
  a.抽象类和抽象方法都是使用abstract来修饰。
  b.抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类
  c.抽象类不能实例化。
  d.抽象的子类:可以是抽象类，也是可以是实例类。
• 抽象类的成员特点：
  a.成员方法：
  有变量，也有常量。（final修饰的变量）
  b.构造方法：
  有构造方法。（用来子类初始化数据使用）
  c.成员方法：
  有抽象，有非抽象。

注意事项：

    1.抽象类有构造方法。但是不能实例化，那么构造有什么作用：
            用于子类反问父类数据的初始化。
    2.一类如果没有抽象方法，却定义类抽象类，有什么作用：
            伪类不让创建对象。
    3.abstract不能和那些关键字共存：
        final (有冲突)； private :（冲突): static:(无意义)

7.接口

• 接口的特点：
  A.接口用关键字 interface 修饰：
  interface 接口名 {}
  B.类实现接口用 implements 修饰
  class 类名 implements 接口名 {}
  C.接口不能被实例化。
  D.接口的实现类
  a.是一个抽象类。
  b.是一个具体类，但必须重新接口中所有抽象方法。
• 接口的成员特点
  A.成员变量：只能是常量(默认修饰符 public static final)
  B.构造方法：没有构造方法。
  C.成员方法:只能是抽象的（默认修饰符 public abstract ）
• 类与类，类与接口，接口与接口之间的关系
  A：类与类：
  集成关系，单继承，但是可以多重继承。
  B：类与接口：
  实现关系，可以单实现，也是可以多实现。（实现的时候逗号隔开）
  还可以在继承以个类的同时，实现多个接口。
  C：接口与接口：
  集成关系，可以但继承，也是可以多继承。（中间使用逗号隔开）

注意一点：Java里面多的多继承是说接口多继承，而不是类的多继承。类是不可以多继承的

• 抽象类与接口的区别
  A：成员区别：
  接口：定义的成员变量都是常量。
  抽象类：定义的成员变量，可以是常量，也可以是变量。
  B：成员方法：
  接口：成员方法都是抽象的方法。
  抽象类：成员方法可以是抽象方法，也可以是具体方法。
  C：构造方法：
  接口：没有构造方法。
  抽象类：有构造方法，但是不能实例化对象。只是提供给子类初始化数据。

持续更新中………………