🤗🤗最近在学习Java，下面是俺整理的韩老师的java视频192~285集笔记，这玩意太上头了，比追剧还过瘾😂，好记性不如烂笔头，虽然东西都很基础，但是温故而知新，欢迎大家进来瞧一瞧，看一看，有误的地方指一指👻，俺接着肝后面几集~
视频链接

---

上篇

对现实世界的理解与抽象：如果只是用变量，赋值语句，表达式，控制语句去构建现实世界模型的话会非常困难，所以面向对象的出现的根本原因就是就是为了解决这个问题，以及这个问题放在工程生产中产生的新的更为复杂的问题。面向对象让我们从指令代码操作变量转变为通过指令操作对象。
面向对象定义

• 猫猫虫小栗子

public class objectOriented {
    public static void main(String[] args) {
        //第一只猫
        Cat cat1 = new Cat();
        cat1.name = "飘飘";
        cat1.age = 3;
        cat1.color = "白";
        //第二只猫
        Cat cat2 = new Cat();
        cat2.name = "马吉吉";
        cat2.age = 5;
        cat2.color = "绿";
        
        System.out.println("第一只猫信息："+cat1.name+'\t'+cat1.age+'\t'+cat1.color);
        System.out.println("第二只猫信息："+cat2.name+'\t'+cat2.age+'\t'+cat2.color);
    }
}
//定义一个猫类
class Cat {
    String name;
    int age;
    String color;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

• 现有技术的主要缺点：不利于数据管理
  

类与对象🎉🎉🎉

属性/成员变量🍳

● 概念上：成员变量 = 属性 = field（也叫字段），成员变量是用来表示属性的
● 属性是类的一个组成部分，一般是基本数据类型，也可以是引用类型（对象、数组）

对象创建🎐

● new一个

// 先声明再创建
Cat cat1;
cat1 = new Cat();
//直接创建
Cat cat1 = new Cat();
1
2
3
4
5

对象机制

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

        Cat cat1 = new Cat();
        cat1.name = "飘飘";
        cat1.age = 3;

        Cat cat2 = cat1;
        System.out.println(cat2.name);
        cat2.age = 5;
        cat2 = null;

        System.out.println(cat1.age);
        System.out.println(cat2.age);
    }
}
//定义一个猫类
class Cat {
    String name;
    int age;
    String color;
}


飘飘
5
Exception in thread "main" java.lang.NullPointerException
	at objectOriented.main(objectOriented.java:14)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

对象机制原理图

• 图1
  
• 图2
  

---

开始加速了~🚀🚀🚀

构造器🚲

构造方法也叫构造器（constructor）是类的一种特殊方法，主要作用：完成对新对象的初始化，并非创建对象。(俺觉得这个像python中的__init__(self)方法一样，确实如此)

● 特点与小细节

1. 构造器与类同名。
2. 每个类可以有一个以上的构造器。
3. 构造器可以有 0 个、1 个或多个参数。
4. 构造器没有返回值。
5. 构造器总是伴随着 new 操作一起调用，工作方式与C++中一样，Java中所有对象都是在堆中构造的，构造器的使用总是与 new 操作符一起使用。
6. 若没有定义构造器，系统会自动给类生成一个默认的无参构造器，可以用 javap 指令反编译看看。
7. 一旦定义了自己的构造器，默认的构造器就被覆盖了，不能再使用默认的无参构造器，除非显示的定义一下。
8. 快捷建：Alt + inserter

public class objectOriented {
    public static void main(String[] args) {
        Person p1 = new Person("香飘飘", 21);

    }
}

class Person {
    String name;
    int age;

    Person(String pName, int pAge) {
        System.out.println("构造器被调用");
        name = pName;
        age = pAge;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

对象创建流程🛻

先看图🍕

---

成员方法🧂

在某些特定方法下，我们需要定义成员方法，如人类：除了属性（性别、年龄、身高、…），我们人类还有一些行为：吃饭、睡觉、学习Java、…。

访问修饰符 返回数据类型 方法名(形参列表) {
    方法体;
    return 返回值;
}
1
2
3
4

● 注意事项

1. 形参列表：表示成员方法的输入，参数类型可以是任意类型
2. 返回数据类型：表示成员方法的输出，void 表示没有返回值
3. return语句不是必须的，但一个方法最多一个返回值，return的值要与回数据类型一致或兼容
4. 访问修饰符：控制方法使用的范围。不写为默认访问
5. 方法名：遵循驼峰命名法，最好见名知意

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

        Cat cat1 = new Cat();
        cat1.name = "飘飘";
        cat1.age = 3;

        cat1.speak();
        int val = cat1.compute(100);

        System.out.println(val);

    }
}
//定义一个猫类
class Cat {
    String name;
    int age;
    String color;

    public void speak() {
        System.out.println("喵喵喵");
    }

    public int compute(int n) {
        return n*(n+1)/2;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

方法调用机制原理图

私有方法

在 Java 中，为了实现一个私有的方法，只需将关键字 public 改为 private 即可。只要方法是私有的，类的设计者就可以确信：它不会被外部的其他类操作调用，可以将其删去。如果方法是公有的，就不能将其删去，因为其他的代码很可能依赖它 。
● final
必须确保在每 一个构造器执行之后，这个域的值被设置， 并且在后面的操作中， 不能够再对它进行修改。 final 修饰符大都应用于基本（primitive ) 类型域，或不可变（immutable) 类的域。

方法重载

Java中允许同一个类中，多个同名方法存在，但要求形参列表不一致。
● 方法名：必须相同
● 形参列表：必须不同（形参类型或个数或顺序，至少有一种不同，参数名无要求）

可变参数🍟

java中允许将一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。

//访问修饰符 返回类型 方法名 (数据类型... 形参名) {
//}
public class Rose {
    public static void main(String[] args){
        ppMethod p = new ppMethod();
        String res = p.grade("马吉吉", 90, 80);
        System.out.println(res);

    }
}
class ppMethod {
    public String grade(String name, double... score) {
        double score_sum = 0;
        for (double v : score) {
            score_sum += v;
        }
        return name + "的总成绩：" + score_sum;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

● 注意细节

1. 可变参数的实参可以是0个或任意多个
2. 可变参数的实参可以是数组
3. 可变参数的本质就是数组
4. 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
5. 一个形参列表只能出现一个可变参数

作用域🍔

1. 在Java中主要的变量就是属性（成员变量）和局部变量。
2. 局部变量一般指的是在成员方法中定义的变量。
3. 作用域的分类：
   a. 全局变量：也就是属性，作用域为整个类体。可以被本类使用，也可以被其他类使用(通过对象调用)
   b. 局部变量：除了属性之外的其他变量，作用域为定义它的代码块中。
4. 全局变量可以不用赋值，直接使用，因为有默认值；局部变量必须赋值后才能使用，因为其没有默认值。

● 注意事项与细节使用

1. 属性和局部变量可以重名，访问遵循就近原则。
2. 在同一个作用域中，如同一成员方法中，两个局部变量，不能重名。
3. 全局变量/属性可以加修饰符，局部变量不可以加修饰符。

• 跨类使用变量

public class objectOriented {
    public static void main(String[] args) {
        Person p1 = new Person();
        T t = new T();
        t.test();

        t.test1(p1);
    }
}

class Person {
    String name = "玛吉吉";
    int age = 99;
    public void say() {
        String name = "香飘飘";
        System.out.println("say() name=" + name);
    }
}
class T {
    public void test() {
        Person p1 = new Person();
        System.out.println(p1.name);
    }
    public void test1(Person p) {
        System.out.println(p.name);
    }
}


玛吉吉
玛吉吉
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

this关键字🎍

Java虚拟机会给每个对象分配 this，代表当前对象。即，哪个对象调用，this就代表那个对象。

1. this关键字可以用来访问本类的属性、方法、构造器。
2. this用来区分当前类的属性和局部变量。
3. 访问成员方法的语法：this.方法名(参数列表);
4. 访问构造器的语法：this(参数列表);只能在构造器中访问另外一个构造器，且必须放在第一条语句。
5. this不能在类定义的外部使用。

public class objectOriented {
    public static void main(String[] args) {
        Person p1 = new Person("香飘飘", 21);
        p1.outPut();
    }
}
class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void outPut() {
        String name = "小椰";
        System.out.println(name + '\t' + age);
        // this 准确的访问属性
        System.out.println(this.name + '\t' + this.age);
    }
}


小椰	21
香飘飘	21
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

包🍕

本质是创建不同的文件夹/目录来保存文件。

1. 需要注意的是， 只能使用 * 导入一个包， 而不能使用 import java.* 或 import java.. 导入以 java 为前缀的所有包，只导入需要的包。
2. 只导入所需的包并不必过多地理睬它们，但在发生命名冲突的时候，就不能不注意包的名字了 。在每个类名的前面加上完整的包名。
3. 要想将一个类放人包中， 就必须将包的名字放在源文件的开头 ，且最多只能有一句package。
4. 命名规则：
   a. 只能包含数字、字母、下划线、小圆点，但不能以数字开头，不能是关键字或保留字。
   b. 命名规范：一般是小写字母+小圆点，如com.公司名.项目名.业务模块名
5. 包的作用域：标记为 public 的部分可以被任意的类使用，标记为 private 的部分只能被定义它们的类使用。如果没有指定 public 或 private , 这个部分（类、方法或变量）可以被同一个包中的所有方法访问。

访问修饰符🎈

● 4种访问修饰符的访问范围
○ 公开级别：用 public 修饰，对外公开。
○ 受保护级别：用 protected 修饰，对子类和同一个包中的类公开。
○ 默认级别：没有修饰符号，向同一个包的类公开。
○ 私有级别：用 private 修饰，只有类本身可以访问，不对外公开。
● 注意事项
○ 修饰符可以用来修饰类中的属性，成员方法以及类。
○ 只有默认的和public才能修饰类，并且遵循上述访问权限的特点。
○ 成员方法的访问规则和属性完全一样。

---