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

最新推荐文章于 2024-07-10 21:37:49 发布

Aunean

最新推荐文章于 2024-07-10 21:37:49 发布

阅读量310

点赞数

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/qq_47168123/article/details/122051450

版权

JavaSE 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

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
我是一个快乐的人
 */

Aunean

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[JavaSE]第四章面向对象(上)

4.1 面向过程和面向对象1.在 Java 语言范畴中，我们都将功能、结构封装到类中，通过类的实例化，来调用具体的功能结构2.涉及到 Java 语言与前端 HTML、后端的数据库交互时，前后端的结构在 Java 层面交互时，都体现为类、对象面向过程(POP) 与面向过程(OOP)二者都是一种思想，面向对象是相对于面向过程而言的面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象：将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做面
复制链接

扫一扫