1. 类与对象的初步认知

        面向过程&＃xff1a;注重过程&＃xff0c;在整个过程中所涉及的行为&＃xff0c;就是功能。
        面向对象&＃xff1a;注重对象&＃xff0c;也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来。

2. 类和类的实例化

        类&＃xff1a;一组具有相同特征的对象的抽象&＃xff0c;对象就是这一类具体化的一个实例&＃xff0c;类中定义了所有该类对象所共同具备的属性和方法。

        类相当于一个模板&＃xff0c;对象是由模板产生的样本。一个类&＃xff0c;可以产生无数的对象。
        所有类的对象都是引用数据类型&＃xff0c;对于引用类型来说&＃xff0c;默认值为 null 。Java 使用关键字 class 来声明类。

 基本语法

// 创建类
class {field;//成员属性method();//成员方法
}
// 实例化对象
<对象名> &＃61; new ();

        class 为定义类的关键字&＃xff0c;ClassName 为类的名字&＃xff0c;{} 中为类的主体。

        类中的元素称为&＃xff1a;成员属性。

        类中的函数称为&＃xff1a;成员方法。

类的实例化

//代码示例
class Person {public int age; //成员属性 实例变量public String name;public String sex;public void eat() { //成员方法System.out.println("吃饭!");}public void sleep() {System.out.println("睡觉!");}
}public class Main{public static void main(String[] args) {Person person &＃61; new Person(); //通过new实例化对象person.eat(); //成员方法调用需要通过对象的引用调用person.sleep();//产生对象 实例化对象Person person2 &＃61; new Person();Person person3 &＃61; new Person();}
}
//输出结果
吃饭!
睡觉!

注意事项
        1. new 关键字用于创建一个对象的实例。
        2. 使用 . 来访问对象中的属性和方法。
        3. 同一个类可以创建对个实例。

3. 类的成员

        类的成员可以包含以下&＃xff1a;字段、方法、代码块、内部类和接口等。

3.1 字段 / 属性 / 成员变量

        在类中&＃xff0c;但是方法外部定义的变量。这样的变量我们称为 "字段" 或 "属性" 或 "成员变量" (三种称呼均可)。用于描述一个类中包含哪些数据。

class Person {public String name; // 字段public int age; // 字段
}
class Test {public static void main(String[] args) {Person person &＃61; new Person();System.out.println(person.name);System.out.println(person.age);}
}
// 执行结果
null
0

注意事项
        1. 使用 . 访问对象的字段。
        2. "访问" 既包含读&＃xff0c;也包含写。
        3. 对于一个对象的字段如果没有显式设置初始值&＃xff0c;那么会被设置一个默认的初值。

默认值规则
        1. 对于各种数字类型&＃xff0c;默认值为 0。
        2. 对于 boolean 类型&＃xff0c;默认值为 false。
        3. 对于引用类型(String&＃xff0c;Array&＃xff0c;以及自定制类)&＃xff0c;默认值为 null。

认识 null

        null 在 Java 中为 "空引用"&＃xff0c;表示不引用任何对象。类似于 C 语言中的空指针。如果对 null 进行 . 操作就会引发异常。

        如果报错 NullPointerException ->空指针异常&＃xff0c;一定使用了一个值为 null 的引用去访问成员属性或者成员方法了。&＃xff08;null 访问 static 属性不报错&＃xff09;

class Person {public String name; //成员属性public int age; //成员属性
}
class Test {public static void main(String[] args) {Person person &＃61; new Person();System.out.println(person.name.length()); // 获取字符串长度}
}
// 执行结果
Exception in thread "main" java.lang.NullPointerException

字段就地初始化

         不使用默认值&＃xff0c;而是显式设定初值的操作。

class Person {public String name &＃61; "张三"; //赋初值public int age &＃61; 18; //赋初值}class Test {public static void main(String[] args) {Person person &＃61; new Person();System.out.println(person.name);System.out.println(person.age);}
}
// 执行结果
张三
18

3.2 方法 (method)

        方法&＃xff1a;用于描述一个对象的行为。

class Person {public int age &＃61; 18;public String name &＃61; "张三";public void show() {System.out.println("我叫" &＃43; name &＃43; ", 今年" &＃43; age &＃43; "岁");}
}class Test {public static void main(String[] args) {Person person &＃61; new Person();person.show(); //调用方法}
}
// 执行结果
我叫张三, 今年18岁


        此处 show 成员方法是和 person 实例对象相关联的。如果创建了其他实例&＃xff0c;那么 show 的行为就会发生变化。

Person person2 &＃61; new Person();
person2.name &＃61; "李四";
person2.age &＃61; 20;
person2.show(); //其他实例调用方法
// 执行结果
我叫李四, 今年20岁


3.3 static 关键字&＃xff08;重点理解&＃xff09;——看见static&＃xff0c;本能反应&＃xff0c;和对象无关

3.3.1 staic修饰的属性&＃xff08;称为类属性&＃xff09;

        Java静态属性和类相关&＃xff0c;和具体的实例对象无关。

        当一个实例变量被 static 关键字修饰&＃xff0c;他就表示类的属性&＃xff0c;该类的所有对象共享这个属性&＃xff0c;所有对象的属性值都一样。

        static 修饰的属性在 JVM 方法区中存储&＃xff0c;所有该类对象共享此属性。

class Person{String name; // 成员变量&＃xff0c;实例变量必须通过该类的对象来访问int age; // 人这个属性中&＃xff0c;需要有单独个体&＃xff0c;才能得出该个体的name、agestatic String country; // 很多对象在堆中共有的成员属性countryvoid show() { // 成员方法&＃xff0c;实例方法&＃xff0c;也是必须通过对象来访问System.out.println("name &＃61; " &＃43; name &＃43;",age &＃61; " &＃43; age &＃43; ",country &＃61; " &＃43; country);}
}public class Main{public static void main(String[] args) {Person per1 &＃61; new Person();per1.name &＃61; "张三";per1.age &＃61; 20;per1.show();Person per2 &＃61; new Person();per2.name &＃61; "李四";per2.age &＃61; 18;per2.show();}
}
//输出结果
name &＃61; 张三,age &＃61; 20,country &＃61; 中国
name &＃61; 李四,age &＃61; 18,country &＃61; 中国

直接通过类名称访问 static 修饰的属性&＃xff0c;无需通过对象访问。 

class Person{static String country &＃61; "中国"; //很多对象在堆中共有的成员属性country}
}public class Main{public static void main(String[] args) {Person per1 &＃61; new Person();System.out.println(Person.country); //用 类 访问static成员属性System.out.println(per1.country); //用 对象 访问static成员属性}
}
//输出结果
中国
中国

问题1&＃xff1a;Java中能否在一个方法内部&＃xff0c;定义一个 static 变量&＃xff1f;

答&＃xff1a;不能&＃xff0c;方法中定义的变量全部都是局部变量&＃xff0c;局部变量在栈中存储&＃xff0c;而static 变量在方法区&＃xff0c;属性不可能同时存在于栈与方法区中。静态 main 方法中同样不能定义static 变量。

问题2&＃xff1a;定义Person per2 &＃61; null&＃xff1b;

             执行 per2.country 是否报错"空指针异常";

public static void main(String[] args) {Person per2 &＃61; null;System.out.println(per2.country);
}
class Person {static String country &＃61; "中国";
}
//输出结果
中国

答&＃xff1a;可以&＃xff0c;static 属性称为类属性&＃xff0c;通过类名称直接访问。故没有对象也可以调用&＃xff08;包含类的null引用&＃xff09;&＃xff0c;而不会出现 NullPointerException ->空指针异常报错。

static 与 final 的区别

class Person {//成员常量&＃xff0c;都在堆中存储&＃xff0c;必须在定义时赋值final int age &＃61; 18;//静态变量&＃xff0c;在方法区中存储&＃xff0c;所有Person的对象共享这个country属性static String country &＃61; "中国";
}

        age 这个属性为成员常量&＃xff0c;在类定义的时候就已赋值为18了。Person的所有对象都有age属性&＃xff0c;且值都是18。把他定义为 static final &＃xff0c;可以节省空间&＃xff0c;并且所有Person对象共享这个属性&＃xff0c;全局唯一。

        故在类中定义常量&＃xff0c;一般使用全局常量&＃xff0c;用 static final 共同修饰。

常量的命名规则

        所有单词全部大写&＃xff0c;多个单词使用下划线分隔。

        如&＃xff0c;static final String STUDENT_SCHOOL &＃61; "清华大学"&＃xff1b;

总结

1. static 变量称为类属性&＃xff0c;在方法区中存储&＃xff0c;该类的所有对象共享此变量。
2. 若在类中定义了常量(定义时赋值)&＃xff0c;一般我们使用 static 和 final 共同修饰变成全局常量。
3. 要使用类属性&＃xff0c;我们通常直接通过类名称 . 属性名称&＃xff0c;不推荐使用对象来调用类属性&＃xff0c;这样不规范。

3.3.2 staic修饰的方法&＃xff08;类方法、工具方法&＃xff09;

        staic修饰的方法&＃xff0c;也是通过类名称直接访问的方法&＃xff0c;没有对象也能访问。

        类方法&＃xff0c;如主方法

---

        工具方法&＃xff0c;如Arrays.sort(int[])、Arrays.copyOf(int[])

        都是Arrays对外提供的操作数组的方法&＃xff0c;将其设计为 static 方法

问题1&＃xff1a;为何主方法是 static 方法&＃xff1f;

答&＃xff1a;主方法是程序的入口。如果主方法是成员方法&＃xff0c;则需要 new 出对象调用&＃xff0c;但没有程序入口&＃xff0c;就产生不了对象。

        程序从主方法开始运行&＃xff0c;主方法要能够调用其他方法&＃xff0c;所以设计为 static &＃xff0c;直接调用而不用产生对象。

---

问题2&＃xff1a;静态方法能否访问成员变量、成员方法&＃xff1f;

答&＃xff1a;不能&＃xff0c;成员方法、成员变量必须通过对象来调用。 static 里面没有该类对象&＃xff0c;所以无法调用。

---

问题3&＃xff1a;成员方法能否访问静态变量、静态方法&＃xff1f;

答&＃xff1a;可以&＃xff0c;有对象才能调用成员方法&＃xff0c;static 没对象都能调用&＃xff0c;更何况有对象&＃xff0c;那就更能调用了。

---

问题4&＃xff1a;外部类能否使用 static 关键字修饰&＃xff1f;

答&＃xff1a;不能&＃xff0c;编译出错。类定义出来就是要产生对象的&＃xff0c;static 类没对象&＃xff0c;就能调用。

总结

1. 在静态方法中只能调用静态方法或者静态属性&＃xff0c;static家族之间可以相互调用。从中不能直接调用成员方法和成员属性&＃xff0c;必须通过对象来调用。

2. 在成员方法中既可以调用成员方法&＃xff0c;也可调用静态方法(此时都已经产生了该类对象&＃xff0c;一定是可以访问静态域的)。

4. 封装

 保护性和易用性

4.1 private&＃xff08;实现封装的方法之一&＃xff09;

        在Java中&＃xff0c;所谓的权限修饰符&＃xff0c;指的是修饰的属性、方法、类&＃xff0c;到底可见的范围有多大。其中一共有四大访问修饰符&＃xff0c;可见的范围又小到大依次为&＃xff1a;

        private

---

        private 私有的&＃xff0c;被private修饰的属性和方法&＃xff0c;只在当前类的内部可见&＃xff0c;出了类就对外部就完全隐藏了&＃xff0c;外部不知道有其存在。

        public 公共的&＃xff0c;公开的被public修饰的属性和方法&＃xff0c;在当前程序(项目)中都是可见的&＃xff0c;都是可以使用的。