2021-08-24（面向对象++JVM底层）

学习内容：

一、类

1.基本概念

简单来说，就是对象抽象出来的东西。比如说，苹果、香蕉抽象出水果。

主要的话，类里面的定义应该分为三类，一个是属性，一个是动作（方法），一个是构造方法
构造函数的话，我没看明白具体是做什么，大致目前理解是一个比较特殊的函数，然后初始化用。

代码示例：

public class studyClass {
//    属性
    int x;
//    构造函数
    public studyClass(int _x){
        x=_x;
    }
//    动作
    public void getValue(){
        System.out.println(x);
    }
}
class test1{
//    进行调用，用new调用
    public static void main(String[] args) {
        studyClass s = new studyClass(4);
        s.getValue();
    }

}

`作业题：

public class studyClass {
    //定义一个点类（x，y），要求可以进行特殊点调用，能够设置点的坐标（内置方法），计算两个点的距离
    double x, y;

    studyClass(double _x, double _y) {
        x = _x;
        y = _y;
    }

    void setPoint(double _x, double _y) {
        x = _x;
        y = _y;
    }

    public double getDistance(studyClass s) {
        return (s.x - x) * (s.x - x) + (s.y - y) * (s.y - y);
    }
}

class test2 {
    public static void main(String[] args) {
        studyClass s1 = new studyClass(4.0, 3.0);
        studyClass s2 = new studyClass(6.0, 30);
        System.out.println(s1.getDistance(s2));
        s1.setPoint(6.0, 30);
        System.out.println(s1.getDistance(s2));
    }
}

2. 构造器的重载

听了老师讲了半天，就感觉不知道为什么要来讲一下，我就把作业做一下，感觉和普通的重载一样，要是理解有错的话，后面再来改改。

重载构造器，使得能够直接new来定义相应的参数

public class studyClass {
    double x, y;

    studyClass() {
    }

    studyClass(double _x, double _y) {
        this.x = _x;
        this.y = _y;
    }

    public double getDistance(studyClass s) {
        return (s.x - x) * (s.x - x) + (s.y - y) * (s.y - y);
    }
}

class test2 {
    public static void main(String[] args) {
        studyClass s1 = new studyClass(4.0, 3.0);
        studyClass s2 = new studyClass(6.0, 30);
        System.out.println(s1.getDistance(s2));
    }
}

3.注意

课程的79-84都随便听了听。主要是讲JVM，应该是非常重要的，这个等后面先找文档多看看，最后再看视频。

4.static

还是拿构造函数举例子，其实基本能理解，静态属性是先于对象存在的，所以可以改变，但是没有赋值之前，还是默认值。
然后，这里的非静态方法和静态语句，没理解，后面看了相关的资料，总结来说就是：

静态语句与非静态语句的周期不同，所以说非静态语句只有在类被实例化后才能使用，而静态是一直存在，直到系统消灭，所以说就能够理解了。下面是具体链接。
链接: https://www.cnblogs.com/sevck/p/4498574.html.

里面还有一个静态初始化块，例子：

public class studyClass {
    double x, y;
    static String z ="circle";//静态初始化，后面就一直使用了。
    studyClass() {
    }
    studyClass(double _x, double _y) {
        this.x = _x;
        this.y = _y;
    }
    public double getDistance(studyClass s) {
        return (s.x - x) * (s.x - x) + (s.y - y) * (s.y - y);
    }
}
class test2 {
    public static void main(String[] args) {
        studyClass s1 = new studyClass(4.0, 3.0);
        studyClass s2 = new studyClass(6.0, 30);
        System.out.println(s1.getDistance(s2)+s1.z);//静态初始化，后面就一直使用了。
    }
}

5.变量分类

变量分类主要就是局部变量（在｛｝内），静态变量（类而言存在），成员变量（对象而言存在），表格总结：

二、包机制

1、简单理解

包对于类就相当于文件夹对于文件。

包的命名：一般是com.company.具体项目

一些常见需要用的包
链接: https://blog.csdn.net/JohnZhongJob/article/details/85803177.

其中java.lang 包不需要导入，直接使用

2、包的导入

例子

package com.lu.test1;
import com.lu.test2.Assitance;
public class Regular {
    public static void main(String[] args) {
        Assitance a=new Assitance();
        a.login();
    }
}

万一冲突用全名：com.lu.test2.Assitance a=new com.lu.test2.Assitance();

导入包里面的类

import com.lu.test2.Assitance.*;

或者说可以直接导入属性

import com.lu.test2.Assitance.*.*;

这里是引用所有属性，还可以不断.下去，变成静态属性

三、面向对象

1、继承

①、简单的继承与instanceof 的使用

package com.lu.test1;

public class Regular {
    public static void main(String[] args) {
        RegularA r = new RegularA();
        System.out.println(r instanceof Regular);
        System.out.println(r instanceof RegularA);
    }
}

class RegularA extends Regular {
}

true
true

对象 instanceof 类，来判断对象是不是按照类的模板或者类后代的模板创建的。

②、方法的重写

子类通过重写父类的方法，就正常的重新写就行，不用担心。

③、final修饰符

举例：

package com.lu.test1;

public class Regular {
   final int age;

    public Regular(int age) {//自动生成了，我猜应该是在使用final时，至少让这个有过一次运动，还有方法是直接int age=0；。
        this.age = age;
    }

    public static void main(String[] args) {
        RegularA r = new RegularA();
        r.age=100;
    }
}

class RegularA extends Regular {

    RegularA() {
        super(age);
    }
}

java: 无法为最终变量age分配值

还可以修饰，变量，方法，类，都表示是最后一次编辑。

④、equals

与==有区别，主要在于==是判断是不是完全相等，equals重写后，可以判断个别值相等，下面是例子：

package com.lu.test1;

import java.util.Objects;

public class Regular {
   final int age=100;


    public static void main(String[] args) {
        RegularA r = new RegularA(1);
        RegularA s = new RegularA(1);
        System.out.println(r==s);
        System.out.println(r.equals(s) );
    }


}


class RegularA extends Regular {
    int id;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        RegularA regularA = (RegularA) o;
        return id == regularA.id;
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }

    public RegularA(int id) {
        this.id = id;
    }
}

equals一般在进行equals验证的那个类里面定义，就是说以后对这个类去判断相等，只需要判断那些就可以了。

⑤、super

可以直接简单看为使用父类，同this一样，要在第一行调用。
例子：

//构造器内默认调用，不断的默认调用执行父类的构造器内容
public class Regular {
    int age = 100;
    Regular() {
        System.out.println("这里是父亲的地盘");
    }
    public static void main(String[] args) {
        RegularA r = new RegularA();
    }
}
class RegularA extends Regular {
}

这里是父亲的地盘

//构造器内自己调用，要在第一行   super();
//其余的调用方式为 super.anotherTest();
package com.lu.test1;

import java.util.Objects;

public class Regular {
    int age = 100;
    Regular() {
        System.out.println("这里是父亲的地盘");
    }
    void anotherTest(){
        System.out.println("再一次，这里是父亲的地盘");
    }
    public static void main(String[] args) {
        RegularA r = new RegularA();
    }
}
class RegularA extends Regular {
    public RegularA() {
        super();
        super.anotherTest();
    }
}

这里是父亲的地盘
再一次，这里是父亲的地盘

封装修饰符的基本分类：

因为这里的protected涉及到子类与父类，这里我们应该注意到的是，同一个包中的时候，子类对父类的对象同样有访问权。但是不同包时，就只有对父类本身了。

2、封装

3、多态

多态里面主要有向上和向下兼容：
链接: https://www.zhihu.com/question/30082151/answer/120520568.

简单来说，就是多态是在 父类名 n = new 子类名（） 这种情况下，n到底具有哪些性质，分别使用哪些方法时的限制，比如静态的就永远是父类的，非静态的是子类的，子类特有的方法不能使用。
其中非静态的方法运行子类的，这就是魅力，多态的。
静态为什么不能运行子类的特有方法，因为编译器只认左边的，非静态的是子类的，是因为在父类方法的基础上重写的。

4、接口

package com.lu.test1;


public class Regular implements Honest {

    @Override
    public void giveHelp() {
        System.out.println("我来飞！");
    }

    @Override
    public void gg() {
        System.out.println("你会飞个屁");
    }

    public void zz(){
        System.out.println("我是正常人，我还不会飞？");
    }

    public static void main(String[] args) {//java中必须要有主方法
        Regular r = new Regular();
        r.gg();
        r.giveHelp();
        r.zz();
    }
}

你会飞个屁
我来飞！
我是正常人，我还不会飞？

与上面的多态相结合，我们可以同样试验一下，用接口作为父类，Regular为子类。

5、接口内的默认方法

public interface Honest {
    int height =100;
    default void moren(){
        System.out.println("这是默认方法");
    }
}

默认方法也可以更改

    @Override
    public void moren() {
        System.out.println("修改后的默认方法");
    }

    public static void main(String[] args) {//java中必须要有主方法
        ReguC r = new ReguC();
        r.gg();
        r.giveHelp();
        r.zz();
        r.moren();
    }

6、接口内的静态方法

静态方法正常定义就行，
以前的其他情况，静态方法的意思就是大家共用一个，谁改了，共用这个类的其他对象也会改。
现在在接口这儿，不能私自改了，只能调用接口的。
举例：

package com.lu.test1;

public interface Honest {
    int height =100;
    default void moren(){
        System.out.println("这是默认方法");
    }

    static void print(){
        System.out.println("我在接口的静态方法打印！！！");
    };
     void giveHelp();
     void gg();
}


//调用
        Honest.print();

7、接口多继承

接口可以进行多继承，直接就是 接口 implement两个接口 就行。

四、String

1、字符串定义：

不可变字符序列

2、字符串比较：

==表示对象是否相同，可以直接用equals。

3、一些方法：

注意 ，string里面都是生成新字符串，原字符串变。
运行一些实验过程：

五、内部类

1、静态内部类：

可以调用外部的静态方法，但非静态的方法不能调用

与非静态内部类的定义方法不同，少一个new

public class Regular {
    static int a = 100;
    int b = 1000;
    static void getName() {
        System.out.println("getName!!!!!!!!!!!!!!");
    }
    void getAge() {
        System.out.println("99!!!!!!!!!!!!!!");
    }
    static class ReguA {
        ReguA() {
        }
        void test() {
            getName();
            System.out.println("我在静态内部类了！！！！！！！！！");
//            getAge();//java: 无法从静态上下文中引用非静态 方法 getAge()
        }
    }
    public static void main(String[] args) {
        Regular.ReguA r = new Regular().ReguA();//与非静态内部类的定义方法不同，少一个new
        r.test();
    }
}

2、非静态内部类：

可以调用外部的所有方法

public class Regular {
    static int a = 100;
    int b = 1000;
    static void getName() {
        System.out.println("getName!!!!!!!!!!!!!!");
    }
    void getAge() {
        System.out.println("99!!!!!!!!!!!!!!");
    }
     class ReguA {
        ReguA() {
        }
        void test() {
            getName();
            System.out.println("我在静态内部类了！！！！！！！！！");
            getAge();//与静态内部类不同，都可以
        }
    }
    public static void main(String[] args) {
        Regular.ReguA r = new Regular().new ReguA();//与静态内部类的定义方法不同，多一个new
        r.test();
    }
}

3、匿名内部类：

只在方法内部使用，一般就在方法调用里面new一下，或者在方法里面new一个。

public class Regular {
    void run() {
        System.out.println("我是外部的" +
                "");
    }
    public void test(Regular a) {
        a.run();
    }
    public static void main(String[] args) {
        Regular r = new Regular();
        r.test(new Regular() {
            @Override
            public void run() {
                System.out.println("new!!!!!!!!!!");
            }
        });
    }
}


new!!!!!!!!!!

注意方法参数内，记住类为 new 类名() {}