[JavaSE] 第四章面向对象(上)

4.1 面向过程和面向对象

1.在 Java 语言范畴中，我们都将功能、结构封装到类中，通过类的实例化，来调用具体的功能结构
2.涉及到 Java 语言与前端 HTML、后端的数据库交互时，前后端的结构在 Java 层面交互时，都体现为类、对象

面向过程(POP) 与面向过程(OOP)
- 二者都是一种思想，面向对象是相对于面向过程而言的
- 面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。
- 面向对象：将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做
面向对象的三大特征
- 封装（Encapsulation）：封装是面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体实现细节，这就是封装思想。便于使用，提高复用性和安全性。
- 继承（Inheritance）：继承性主要描述的是类与类之间的关系，通过继承，可以在无需重写编写原有类的情况下，对原有类的功能进行扩展。提高代码复用性；继承是多态的前提。
- 多态（Polymorphism）：父类或接口定义的引用变量可以指向子类或具体实现类的实例对象。提高了程序的拓展性。

4.2 类和对象

4.2.1 类的定义

类（Class）和对象（Object）是面向对象的核心概念
- 类是对一类事物的描述，是抽象的、概念上的定义
- 对象是实际存在的该类事物的每个个体，因而也称为实例（instance）
- 面向对象程序设计的重点是类的设计
- 类的设计，其实就是类的成员的设计
- 类中可以定义成员变量和成员方法
  - 成员变量用于描述对象的特征，也被称作属性
  - 成员方法用于描述对象的行为

属性 = 成员变量 = field = 域、字段
方法 = 成员方法 = 函数 = method

创建类的对象 = 类的实例化 = 实例化类

4.2.2 对象的创建和使用

一般步骤
1. 创建类、设计类的成员
2. 创建类的对象
3. 通过对象.属性或对象.方法调用对象的结构
类的访问机制
- 在一个类中的访问机制：类中的方法可以直接访问类中的成员变量（例外：static方法访问非static，编译不通过）
- 在不同类中的访问机制：先创建要类的对象，再用对象访问类中定义的成员

public class PersonTest {
    public static void main(String[] args) {
        //2.创建 Person 类的对象
        Person person = new Person();

        //调用对象的结构：属性、方法
        //调用属性：对象.方法
        person.name = "Tom";
        person.isMale = true;
        System.out.println(person.name);

        //调用方法：对象.方法
        person.eat();
        person.talk("汉语");

        //**********************************
        Person person1 = new Person();
        System.out.println(person1.name);

        //赋值：将 person 变量保存的对象地址值赋给 person2，导致 person 和 person2 指向了堆空间中的同一个对象实体
        Person person2 = person;
        System.out.println(person2.name);
        person2.age = 10;
        System.out.println(person.age);
    }
}

//1.创建类、设计类的成员
class Person {
    //属性
    String name;
    int age;
    boolean isMale;

    //方法
    public void eat() {
        System.out.println("人需要吃饭");
    }

    public void talk(String language) {
        System.out.println("人可以说话，使用的是：" + language);
    }
}

4.2.3 类的封装

问题引入：

当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。
这里，赋值操作要受属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。
但是，在实际问题中，我们往往需要给属性赋值，并加入额外的限制条件。
这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。
(比如: set同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。
则需要将属性声明为私有的(private)
此时，针对于属性就体现了封装性。

封装性的体现

我们将属性xx私有化(private)，同时提供公共的(public)方法来获取(getXx)和设置(setXx)此属性
拓展：封装性的体现：①成员变量的私有化，②方法的私有化，③单例模式 ....

封装性的体现，需要权限修饰符来配合。

Java 规定的 4 种权限（从小到大排序）：private、缺省、protected、public
4 种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
修饰类的话，只能使用：缺省、public

总结封装性：Java 提供了四种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小
封装性的作用

隐藏对象的内部的复杂性，只对外公开简单的接口。便于外界调用，从而提供系统的可扩展性、可维护性。
通俗的说，就是把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想
- 高内聚：类的内部数据操作细节自己完成，不允许外部干涉
- 低耦合：仅对外暴露少量的方法用于使用

package com.ws.encapsulation;

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

        Animal a = new Animal();
        a.name = "大黄";

        a.setAge(3);
        a.setLegs(4);
        a.show();
    }
}

class Animal {
    //属性
    String name;
    private int age; // 将 age 属性私有化
    private int legs;

    //对属性的设置
    public void setLegs(int i) {
        if (i >= 0 && i % 2 == 0) {
            legs = i;
        } else {
            legs = 0;
        }
    }

    //对属性的获取
    public int getLegs() {
        return legs;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void eat() {
        System.out.println("进食");
    }

    public void show() {
        System.out.println("name = " + name + ", age = " + age + ", legs = " + legs) ;
    }
}

Java 权限修饰符 public、protected、(缺省)、private 置于类的成员定义前，用来限定对象对该类成员的访问权限。

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	yes
缺省（default）	yes	yes
protected	yes	yes	yes
public	yes	yes	yes	yes

对于 class 的权限修饰只可以用 public 和 default(缺省)。

4.3 类的成员之一：属性

4.3.1 属性的使用

语法格式：
- 修饰符数据类型属性名 = 初始化值;
  - 修饰符
    - 常用的修饰符：private、缺省、protected、public
    - 其他修饰符：static、final
  - 数据类型
    - 任意基本数据类型或引用数据类型
  - 属性名
    - 属于标识符，符合命名规则和规范即可
变量的分类：成员变量和局部变量
- 在方法体外，类体内声明的变量称为成员变量
- 在方法体内部声明的变量称为局部变量

成员变量（属性）和局部变量的相同点
- 定义变量的格式
- 先声明，后使用
- 变量都有其对应的作用域

成员变量（属性）和局部变量的区别

成员变量	局部变量
直接声明在类中	方法内、方法形参、代码块内、构造器形参、构造器内部的变量	声明的位置
private、public、static、final 等	不可用使用权限修饰符，可以用 final 修饰	修饰符
有默认初始化值	没有默认初始化值，必须显式赋值，方可使用形参在调用时，赋值即可	初始化值
堆空间或静态域内（非 static 的）	栈空间	内存加载位置

public class UserTest {
    public static void main(String[] args) {
        User u1 = new User();
        System.out.println(u1.name);
        System.out.println(u1.age);
        System.out.println(u1.isMale);

        u1.tale("汉语");
    }
}

class User {
    //属性（成员变量）
    String name;
    int age;
    boolean isMale;

    public void tale(String language) {//language：形参
        System.out.println("我们使用" + language + "进行交流");
    }

    public void eat() {
        String food = "烙饼";//局部变量
        System.out.println("北方人喜欢吃：" + food);
    }
}

4.3.2 属性赋值过程

赋值的位置：
- 默认初始化
- 显式初始化
- 构造器中初始化
- 通过 “对象.属性” 或 “对象.方法” 的方式赋值
赋值的先后顺序
- ① 默认初始化 -> ② 显式初始化 -> ③ 构造器中初始化 -> ④ 通过 “对象.属性” 或 “对象.方法” 的方式赋值

4.4 类的成员之二：方法

4.4.1 方法含义

方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程
将功能封装为方法的目的是，可以实现代码重用，简化代码
Java 里的方法不能独立存在，所有的方法必须定义在类里

4.4.2 语法格式

修饰符 返回值类型 方法名([参数类型 参数名1, 参数类型 参数名2, ...]){
	方法体
	...
	return 返回值;
}

修饰符：
- 权限修饰符：Java 规定的四种权限修饰符：private、public、缺省、protected
- 静态修饰符：static
- 最终修饰符：final
- 抽象方法：abstract
返回值类型：用于限定方法返回值的数据类型
参数类型：用于限定调用方法时传入参数的数据类型
参数名：用于接收调用方法时传入的数据。形参
return 关键字：用于结束方法以及返回方法指定类型的值
返回值：被 return 语句返回的值，该值会返回给调用者

4.4.3 简单使用

public class CustomerTest {
    public static void main(String[] args) {
        Customer customer1 = new Customer();
        customer1.sleep(7);
    }
}

//客户类
class Customer {

    //属性
    String name;
    int age;
    boolean isMale;

    //方法
    public void eat() {
        System.out.println("客户吃饭");
        return;
    }

    public void sleep(int hour) {
        System.out.println("休息了" + hour + "个小时");
        eat();
        sleep(10);
    }

    public String getName() {
        if (age > 18) {
            return name;
        }
        return "Tom";
    }
}

4.4.4 方法重载

重载的概念：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或参数类型不同即可（两同一异：同一个类，同一个方法名、参数列表不同）

重载的特点：跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系，只看参数列表（参数类型不同或参数个数不同）。调用时，根据方法参数列表的不同来区别。

使用

public class OverLoadTest {

    public void getSum(int i, int j) {
        System.out.println(i + j);
    }

    public void getSum(double i, double j) {
        System.out.println(i + j);
    }

    public static void main(String[] args) {
        OverLoadTest test = new OverLoadTest();
        test.getSum(1, 3.4);
    }
}

4.4.5 方法参数的值传递机制

方法，必须由其所在类或对象调用才有意义。若方法含有参数:
- 形参：方法声明时的参数
- 实参：方法调用时实际传给形参的参数值
Java 的实参值如果传入方法呢？

Java 里方法的参数传递方式只有一种：值传递。即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响
- 形参是基本数据类型：将实参的基本数据类型变量的 ”数据值“ 传给形参
- 形参是引用数据类型：将实参引用数据类型变量的 ”地址值“ 传给形参

使用

package com.ws.function;

import com.sun.org.apache.xpath.internal.operations.Or;

/*
关于变量的赋值

如果变量是基本数据类型，此时赋值的是变量所保存的数据值
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值

 */
public class ValueTransferTest {
    public static void main(String[] args) {

        System.out.println("**********基本数据类型：************");
        int m = 10;
        int n = m;
        System.out.println("m = " + m + ", n = " + n);//m = 10, n = 10

        n = 20;
        System.out.println("m = " + m + ", n = " + n);//m = 10, n = 20

        System.out.println("***********引用数据类型：************");
        Order o1 = new Order();
        o1.id = 1001;
        Order o2 = o1;
        System.out.println("o1 = " + o1.id + ", o2 = " + o2.id);//o1 = 1001, o2 = 1001

        o2.id = 1002;
        System.out.println("o1 = " + o1.id + ", o2 = " + o2.id);//o1 = 1002, o2 = 1002
    }
}

class Order {
    int id;
}

    public static void main(String[] args) {

        int m = 10;
        int n = 20;
        //交换两个变量的值的操作
//        int temp = m;
//        m = n;
//        n = temp;
        System.out.println("m = " + m + ", n = " + n);//m = 10, n = 20

        ValueTransferTest2 test2 = new ValueTransferTest2();
        test2.swap(m, n);
        System.out.println("m = " + m + ", n = " + n);//m = 10, n = 20
    }

    public void swap(int m, int n) {
        int t = m;
        m = n;
        n = t;
        System.out.println("m = " + m + ", n = " + n);//m = 20, n = 10
    }

public class ValueTransferTest3 {

    public static void main(String[] args) {

        Data data = new Data();
        data.m = 10;
        data.n = 20;

        System.out.println("m = " + data.m + ", n = " + data.n);//m = 10, n = 20

        ValueTransferTest3 test3 = new ValueTransferTest3();
        test3.swap(data);
        System.out.println("m = " + data.m + ", n = " + data.n);//m = 20, n = 10

    }

    public void swap(Data data) {
        int temp = data.m;
        data.m = data.n;
        data.n = temp;
    }
}

class Data {
    int m;
    int n;
}

4.4.6 递归方法

递归方法：一个方法体内调用它自身。
方法递归包含一种隐式的循环，它会重复执行某段代码，但这种重复执行无需循环控制
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环

使用

public class RecursionTest {

    public static void main(String[] args) {
        //例1：计算 1-100 之间所有自然数的和
        //方式一：
//        int sum = 0;
//        for (int i = 1; i < 101; i++) {
//            sum += i;
//        }
//        System.out.println(sum);

        //方式二：
        RecursionTest test = new RecursionTest();
        int sum = test.getSum(100);
        System.out.println(sum);

        int product = test.getProduct(4);
        System.out.println(product);

        int f = test.f(10);
        System.out.println(f);

        int fibonacci = test.Fibonacci(10);
        System.out.println(fibonacci);
    }

    public int getSum(int n) {
        if (n == 1) {
            return 1;
        } else {
            return n + getSum(n - 1);
        }
    }

    //计算 1-n 之间所有自然数的乘积
    public int getProduct(int n) {
        if (n == 1) {
            return 1;
        } else {
            return n * getProduct(n - 1);
        }
    }

    //例3:已知有一个数列:f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n)
    // 其中n是大于0的整数，求f(10)的值。
    public int f(int n) {
        if (n == 0) {
            return 1;
        } else if (n == 1) {
            return 4;
        } else {
            return 2 * f(n - 1) + f(n - 2);
        }
    }

    //例4：输入一个数据 n，计算斐波那契数列的第 n 个值
    //规律：一个数等于前两个数之和
    public int Fibonacci(int n) {
        if (n == 1 || n == 2) {
            return 1;
        } else {
            return Fibonacci(n - 1) + Fibonacci(n - 2);
        }
    }
}

4.5 类的成员之三：构造器

4.5.1 构造器的使用

构造器的特征
- 具有与类相同的名称
- 不声明返回值类型（与声明为 void 不同）
- 不能被 static、final、synchronized 、abstract、native 修饰，不能有 return 语句返回值
构造器的作用：
- 创建对象；给对象进行初始化
- 构造器重载使得对象的创建更加灵活方便创建各种不同的对象（构造器重载，参数列表必须不同）
说明：

1.如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器
2.定义构造器的格式：权限修饰符类名([形参列表]){}
3.一个类中定义的多个构造器，彼此构成重载
4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
5.一个类中，至少会有一个构造器

使用

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

        //创建类的对象：new + 构造器
        Person person = new Person();
        Person person1 = new Person("Tom");
    }
}

class Person {
    //属性
    String name;
    int age;
    
    //构造器
    public Person() {
    }
    public Person(String name) {
        this.name = name;
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat() {
        System.out.println("人吃饭");
    }
    public void age() {
        System.out.println("年龄");
    }
}

4.5.2 JavaBean

JavaBean 是一种 Java 语言写成的可重用组件
所谓 JavaBean，是符合如下标准的 Java 类：
- 类是公共的
- 有一个无参的公共的构造器
- 有属性，且有对应的 get、set 方法

4.6 this 关键字

4.6.1 this 是什么？

在 Java 中，this 关键字比较难以理解，它的作用和其词义很接近
- 它在方法内部使用，即这个方法所属对象的引用
- 它在构造器内部使用，表示该构造器正在初始化的对象
this 可以调用类的属性、方法和构造器
什么时候使用 this 关键字？
- 当在方法内需要用到调用该方法的对象时，就用 this
- 具体的：我们可以用 this 来区分属性和局部变量

4.6.2 this 关键字的使用

this可以用来修饰：属性、方法、构造器
this修饰属性和方法
- this理解为：当前对象
- 在类的方法中：我们可以使用 "this.属性" 或 "this.方法" 的方式，调用当前对象的属性或方法。但是，通常情况下，我们都选择省略 "this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显示的使用 "this.变量" 的方式，表名此变量是属性，而非形参。
- 在类的构造器中：我们可以使用 "this.属性" 或 "this.方法" 的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都选择省略 "this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显示的使用 "this.变量" 的方式，表名此变量是属性，而非形参。
this 调用构造器
- 我们在类的构造器中，可以显式的使用 "this(形参列表)"方式，调用本类中指定的其他构造器
- 构造器中不能通过 "this(形参列表)" 方式调用自己
- 如果一个类中有 n 个构造器，则最多有 n - 1 个构造器中使用了 "this(形参列表)"
- "this(形参列表)" 必须声明在当前构造器中的首行
- 构造器内部，最多只能声明一个 "this(形参列表)"，用来调用其他构造器

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

        Person person = new Person("Tom", 23);

        person.setAge(3);
        int age = person.getAge();
        System.out.println(age);
    }
}

class Person {

    private String name;
    private int age;

    public Person() {//无参构造方法
        System.out.println("info*************");
    }
    public Person(String name) {
        this();
        this.name = name;
    }
    public Person( int age) {
        this();
        this.age = age;
        System.out.println("int age");
    }
    public Person(String name, int age) {
        this(age);
        this.name = name;
        System.out.println("String name, int age");
        //this.age = age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
}

4.7 static 关键字

static 可以用来修饰：属性、方法、代码块、内部类

4.7.1 静态变量

使用 static 修饰属性：静态变量
- 属性：按是否使用 static 修饰，又分为：静态属性 vs 非静态属性（实例变量）
  - 实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象的非静态属性时，不会导致其他对象中同样的属性值的修改。
  - 静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。
- static 修饰符属性的其他说明：
  - 静态变量随着类的加载而加载，可以通过 “类.静态变量”的方式进行调用
  - 静态变量的加载要早于对象的创建
  - 由于类只会加载一次，则静态变量在内存中也只会加载一次
  - 静态变量可以通过类或对象来调用；实例变量只能通过对象来调用，不能通过类来调用
- 静态属性举例：System.out, Math.PI

4.7.2 静态方法

使用 static 修饰方法：静态方法
- 随着类的加载而加载，可以通过“类.静态方法”进行调用
- 静态方法可以通过类和对象进行调用，非静态方法只能通过对象进行调用
- 静态方法中，只能调用静态的方法或属性
- 非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
在静态的方法内，不能使用 this 和 super 关键字
关于静态属性和静态方法的使用，从生命周期去考虑
开发中，如何确定一个属性是否要声明为 static 的？
- 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
- 类中的常量也常常声明为 static
开发中，如何确定一个方法是否要声明为 static 的？
- 操作静态属性的方法，通常设置为 static 的
- 工具类中的方法，习惯上声明为 static 的。比如：Math、Arrays、Collections

public class StaticTest {
    public static void main(String[] args) {
        Chinese.nation = "China";
//        Chinese.name = "xxx"; //非静态属性不能通过类进行调用
        Chinese c1 = new Chinese();
        c1.name = "姚明";
        c1.age = 40;
        c1.nation = "CHN";

        Chinese c2 = new Chinese();
        c2.name = "马龙";
        c2.age = 30;

        System.out.println(c2.nation);

        Chinese.show();
//        Chinese.eat();

    }

}

class Chinese {

    String name;
    int age;
    static String nation;

    public void eat() {
        System.out.println("吃早饭");
        //调用非静态结构
        System.out.println(age);
        this.info();

        //调用静态结构
        System.out.println(nation);
        Chinese.walk();
    }

    public void info(){}

    public static void show() {
        System.out.println("事实是事实");
        System.out.println(nation);
        Chinese.walk();
        //不能调用非静态的结构
//        this.info();
//        System.out.println(name);//Non-static field 'name' cannot be referenced from a static context
    }

    public static void walk() {}
}

4.7.3 单例设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、

以及解决问题的思考方式

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为 private，这样，就不能用 new 操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。

饿汉式：

好处：饿汉式是线程安全的
坏处：对象加载时间过长

class Bank {

    //1.私有化类的构造器
    private Bank() {

    }

    //2.内部创建类的对象
    //4.要求此对象也必须声明为静态的
    private static Bank instance = new Bank();

    //3.提供公共的静态方法，返回类的对象
    public static Bank getInstance() {
        return instance;
    }
}

懒汉式：

好处：延迟对象的创建。
目前的写法坏处：线程不安全 ---> 到多线程内容时，再修改

class Order {

    //1.私有化类的构造器
    private Order() {}

    //2.声明当前类对象，没有初始化
    //4.此方法也必须声明为static的
    private static Order instance = null;

    //3.声明public、static的返回当前类对象的方法
    public static Order getInstance() {
        if (instance == null)
        instance = new Order();

        return instance;
    }
}

4.8 类的成员之四：代码块

代码块的作用：用来初始化类、对象
代码块如果有修饰的话，只能使用 static
分类：静态代码块 vs 非静态代码块

4.8.1 静态代码块

静态代码块
- 内部可以有输出语句
- 随着类的加载而执行，而且只执行一次
- 作用：初始化类信息
- 如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
- 静态代码块的执行要优先于非静态代码块的执行
- 静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构

4.8.2 非静态代码块

非静态代码块
- 内部可以有输出语句
- 随着对象的创建而执行
- 每创建一个对象，就执行一次非静态代码块
- 作用：可以在创建对象时，对对象的属性进行初始化
- 如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
- 非静态代码块内可以调用静态的结构，也可以调用非静态的结构

/*
对属性可以赋值的位置：
① 默认初始化
② 显式初始化
③ 构造器中初始化
④ 有了对象以后，可以通过 "对象.属性" 或 "对象.方法" 的方式，进行赋值
⑤ 在代码块中赋值

执行的先后顺序
① -> ②/⑤ -> ③ -> ④
*/
public class BlockTest {
    public static void main(String[] args) {

        String desc = Person.desc;
        System.out.println(desc);

        Person p1 = new Person();
        new Person();

        Person.info();
    }
}

class Person {
    //属性
    String name;
    int age;
    static String desc = "我是一个人";

    //构造器
    public Person() {

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

    //static代码块
    static {
        System.out.println("hello, static block-1");
        desc = "我是一个坏人";
    }
    static {
        System.out.println("hello, static block-2");
        desc = "我是一个坏人";
    }

    //非static代码块
    {
        System.out.println("hello block");
        age = 10;
    }

    //方法
    public void eat() {
        System.out.println("人吃饭");
    }

    public static void info() {
        System.out.println("我是一个快乐的人");
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
/*
hello, static block-1
hello, static block-2
我是一个坏人
hello block
hello block
我是一个快乐的人
 */

posted @ 2021-12-20 22:03 Aunean 阅读(48) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

阅读排行：
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· 单线程的Redis速度为什么快？
· SQL Server 2025 AI相关能力初探
· AI编程工具终极对决：字节Trae VS Cursor，谁才是开发者新宠？
· 展开说说关于C#中ORM框架的用法！

公告

昵称： Aunean
园龄： 3年9个月
粉丝： 0
关注： 2

+加关注

2025年3月

日

一

二

三

四

五

六

随笔分类 (12)

随笔档案 (12)

文章分类 (1)

Java(1)

Aunean

[JavaSE] 第四章面向对象(上)

4.1 面向过程和面向对象

4.2 类和对象

4.2.1 类的定义

4.2.2 对象的创建和使用

4.2.3 类的封装

4.3 类的成员之一：属性

4.3.1 属性的使用

4.3.2 属性赋值过程

4.4 类的成员之二：方法

4.4.1 方法含义

4.4.2 语法格式

4.4.3 简单使用

4.4.4 方法重载

4.4.5 方法参数的值传递机制

4.4.6 递归方法

4.5 类的成员之三：构造器

4.5.1 构造器的使用

4.5.2 JavaBean

4.6 this 关键字

4.6.1 this 是什么？

4.6.2 this 关键字的使用

4.7 static 关键字

4.7.1 静态变量

4.7.2 静态方法

4.7.3 单例设计模式

4.8 类的成员之四：代码块

4.8.1 静态代码块

4.8.2 非静态代码块

公告

搜索

常用链接

我的标签

随笔分类 (12)

随笔档案 (12)

文章分类 (1)

阅读排行榜

Aunean

[JavaSE] 第四章 面向对象(上)

4.1 面向过程和面向对象

4.2 类和对象

4.2.1 类的定义

4.2.2 对象的创建和使用

4.2.3 类的封装

4.3 类的成员之一：属性

4.3.1 属性的使用

4.3.2 属性赋值过程

4.4 类的成员之二：方法

4.4.1 方法含义

4.4.2 语法格式

4.4.3 简单使用

4.4.4 方法重载

4.4.5 方法参数的值传递机制

4.4.6 递归方法

4.5 类的成员之三：构造器

4.5.1 构造器的使用

4.5.2 JavaBean

4.6 this 关键字

4.6.1 this 是什么？

4.6.2 this 关键字的使用

4.7 static 关键字

4.7.1 静态变量

4.7.2 静态方法

4.7.3 单例设计模式

4.8 类的成员之四：代码块

4.8.1 静态代码块

4.8.2 非静态代码块

公告

搜索

常用链接

我的标签

随笔分类 (12)

随笔档案 (12)

文章分类 (1)

阅读排行榜

[JavaSE] 第四章面向对象(上)