快速掌握类和对象

标签：初始化 代码 变量 掌握 对象 成员 static 快速 public

目录

• 1. 面向对象的概念
• • 1.1 面向对象的编程步骤
• 2. 类
• • • 2.1 类的详解
    • 2.2 类的实例化 --- 对象
• 3. 对象
• • • 3.1 对象的构造及初始化
    • 3.2 构造方法
    • 3.3 默认初始化
• 4. this关键字
• 5. static关键字
• • • 5.1 为什么要有static
    • 5.2 static修饰成员变量---类变量
    • 5.3 static修饰成员方法---类方法
    • 5.4 static成员变量初始化
• *代码块
• • • 1. 代码块的分类
    • • • 1.1 普通代码块
        • 1.2 构造块 （构造代码块）
        • 1.3 静态块 （静态代码块）
        • 1.4 同步代码块（后续讲解多线程部分再谈）
    • 2. 不同类型代码块的执行顺序
• 6. 对象的打印

1. 面向对象的概念

1.1 面向对象的编程步骤

1. 找对象
2. 创建对象
3. 使用对象

2. 类

类，指自定义类型，不占用内存空间，不存储任何数据

2.1 类的详解

【类的格式】类名采用大驼峰形式
【类中的内容】又称类的成员，包含成员变量(静态/普通)和成员方法(静态/普通)

class Dog {
    //普通成员变量
    public String name;
    //静态成员变量
    public static int age;

    //普通成员方法
    public void barks() {
        System.out.println(this.name+"汪汪汪");
    }
    //静态成员方法
    public static void barks(String name){
        System.out.println(name+"汪汪汪");
    }
}

【类的编译】每个类在编译后，会生成.class文件(字节码文件)

【注】

1. 建议一个java文件写一个类，不要写多个
2. main方法所在的类一般要使用public修饰
3. public修饰的类必须要和文件名相同
4. 不要轻易去修改public修饰的类的名称，如果要修改，通过Reactor的Rename修改

2.2 类的实例化 — 对象

定义了新的类只是定义了一个新的类型，想要使用，需要将类实例化（构建对象）

【代码演示】

public static void main(String[] args) {
    Dog dog = new Dog();
    dog.barks();
}

【底层图示】

【注】

1. new是关键字，用于实例化对象
2. Java中的 . 操作符用于访问对象中的成员(静态成员不属于对象)

3. 对象

对象，由类实例化而来，占用内存空间，存储数据

3.1 对象的构造及初始化

之前在main方法中创建变量必须初始化，否则会编译失败。同理通过类创建对象也需要初始化，用new关键字来初始化

    public static void main(String[] args) {
        Dog dog = new Dog();
    }

【初始化对象的方式】

1. 就地初始化(创建成员变量的同时赋值)
2. 不初始化(默认初始化)
3. 构造方法初始化(常用)

【提问】

public void setName(String name) {
    System.out.println(name);
}

1. 初始化成员变量除了调用setName方法外，能不能在初始化时就赋值完？用构造方法初始化
2. 局部变量必须初始化，为什么成员变量可以不初始化？默认初始化

3.2 构造方法

【构造方法概念】

1. 构造方法又称为构造器，是一个特殊的成员方法。该方法名与类同名，创建对象时自动调用构造方法，并且在对象的生命周期内只调用一次。
2. 构造方法只是对成员变量进行初始化，不负责为对象开辟空间

【构造方法的使用】

class Dog {
    public String name;
    public int age;

    //构造方法重载
    public Dog(String name){
        this.name = name;
    }
    public Dog(String name,int age){
        this.name = name;
        this.age = age;
    }
}

【注】

1. 构造方法一般用public修饰，特殊场景下会被private修饰(后序讲单例模式时会遇到)
2. 构造方法没有返回值类型，void也不行
3. 构造方法可以重载
4. 如果定义类时没有定义构造方法，编译器会提供一份不带参数的构造方法，一旦用户定义，编译器则不再生成
5. 构造方法中可用this调用其他构造方法，但this语句必须放在构造方法的第一行，且不能互相调用

3.3 默认初始化

new一个对象时，JVM层面会做许多事，这里只讲三件事：

1. 为对象分配内存
2. 初始化所分配的空间（完成这一步后，类的成员会被分配内存，内存中数据初始化为默认值）
3. 调用合适的构造方法

4. this关键字

【为什么要有this引用】

根据如下代码，有两个问题：

1. 形参和成员变量同名时，到底给谁赋值？用this
2. 两个对象都调用了同一个方法，编译器怎么知道是谁调的？用this

【this引用的概念】this引用的是当前调用成员方法的对象，只能在成员方法（或构造方法）中使用

问题一解决：形参和成员变量同名时，局部变量（形参）优先，不能成功给成员变量赋值。用this修饰，this引用的是当前对象
问题二解决：成员方法会有一个隐藏参数this作为方法的第一个参数

【this的应用】

public void setDay(int year, int month, int day){
	year = year;
	month = month;
	day = day;
}
//问题一的解决
public void setDay(int year, int month, int day){
	this.year = year;
	this.month = month;
	this.day = day;
}
//问题二的解决  setDay是Date类的成员方法
public void setDay(Date this,int year, int month, int day){
	this.year = year;
	this.month = month;
	this.day = day;
}

【this用法总结】

1. this.成员变量
2. this.成员方法
3. this() ，只能放在第一行

5. static关键字

5.1 为什么要有static

假设三个同学是同一个班的，他们上课是在同一个教室，能否给类中再加一个成员变量，来保存同学上课时的教室呢？不能
类是描述对象信息的，成员变量在实例化为对象后，对象会有一份实例变量。可使用这些信息来描述具体的学生信息，如姓名，年龄，这些是对象所特有的属性，而教室是学生集合所共有的，不单独属于某个对象。

static修饰的成员，称之为静态成员，其不属于某个对象，而是所有对象所共有的。 就好比作为学生，名字是所有人都有的成员变量，在类实例化后成员变量变为实例变量，名字这个实例变量属于你，但你的老师不属于你，老师是所有学生共有的变量

5.2 static修饰成员变量—类变量

静态成员变量又叫类变量，有如下特性：

1. 是所有对象共享的，不存储在某个对象的空间中
2. 可以通过对象或类名访问，这里要求用类名访问
3. 成员变量这种类的信息和类变量存储在方法区，实例成员变量存储在堆
4. 生命周期伴随类的一生

【代码演示】

class Dog {
    //普通成员变量
    public String name;
    public int age;
    //静态成员变量
    public static String teacher;
}

1.用类可以点出类变量

2.用对象可以点出普通成员变量

创建Dog对象后调试代码，对象中只有name和dog两个成员变量，没有静态成员变量

5.3 static修饰成员方法—类方法

一般类中的成员变量都设置为private，而成员方法设置为public，那如何访问类变量？静态成员一般是通过静态方法来访问的。

静态成员变量又叫类变量，有如下特性：

1. 可以通过对象或类名调用，要求使用类名
2. 不能在静态方法中访问任何非静态成员，因为有this，而this是对象特有的，不属于类

【代码演示】

class Dog {
    private static String teacher;
    public static String getTeacher(){
        return teacher;
    }
}

当getTeacher方法没有被static修饰时，类名点不出来getTeacher

5.4 static成员变量初始化

类变量不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性

【初始化方式】

1. 就地初始化(创建成员变量的同时赋值)
2. 静态代码块初始化
3. 不初始化(默认初始化)

//就地初始化
private static String teacher = "十八";
//默认初始化
private static String classRoom = "001";
//静态代码块初始化
static {
    teacher = "hh";
    classRoom = "002";
}

*代码块

使用 {} 定义的一段代码称为代码块。

1. 代码块的分类

1.1 普通代码块

普通代码块：定义在方法内的代码块，代码块内定义的内容与代码块外无关

1.2 构造块 （构造代码块）

构造代码块：又叫实例代码块，定义在类内的代码块，一般用于初始化实例成员变量

【代码演示】

private static String teacher = "十八";
private static String classRoom = "001";

{
    teacher = "aa"; //实例代码块中 可以 访问静态成员
    this.age = 15;
    System.out.println(this.age+"实例代码块");
}

1.3 静态块 （静态代码块）

静态代码块：定义在类内的代码块，一般用于初始化类变量

【代码演示】

private static String teacher = "十八";
private static String classRoom = "001";

static {
    teacher = "hh";
    classRoom = "002";
    this.age = 18; //静态代码块中 不可以 访问实例成员
    System.out.println(classRoom + "静态代码块");
}

1.4 同步代码块（后续讲解多线程部分再谈）

2. 不同类型代码块的执行顺序

【执行顺序】
new一个对象时，先执行静态成员变量和方法；再执行实例代码块；再执行构造方法。

public static void main(String[] args) {
    Dog dog = new Dog("旺旺");
    System.out.println();
    Dog dog1 = new Dog("西西");
}

//执行结果
002静态代码块
15实例代码块
旺旺

15实例代码块
西西

【注】

1. 静态代码块不管生成多少个对象，只会执行一次
2. 实例代码块只在创建对象时执行
3. 如果一个类中有多个静态代码块，编译器会按照定义的先后次序依次执行
4. 类变量是类的属性，因此是在JVM加载类时开辟空间并初始化的

6. 对象的打印

若对类的成员变量进行封装后，打印对象只打印了哈希值。如何打印对象的内容？

public static void main(String[] args) {
    Dog dog = new Dog("旺旺");
    System.out.println(dog); //Dog@7c53a9eb
}

【查看println源代码】



从println源代码可以看出，最终决定打印结果的是toString方法，那么只要重写toString方法即可

【重写toString方法】alt+insert

//在Dog类中重写toString
@Override
public String toString() {
    return "name=" + name +" age=" + age+"狗狗";
}

//测试打印结果
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("旺旺");
        System.out.println(dog); //name=旺旺 age=0狗狗
    }
}

标签：初始化,代码,变量,掌握,对象,成员,static,快速,public
From： https://blog.csdn.net/2301_79417489/article/details/141303579