JavaSE：类与对象

1.什么是面向对象？
2.类
- 2.1认识一下类
- 2.2类的定义格式
- 2.3类要注意的问题
3.类的实例化
4.类和对象（重点）
5.this引用
- 5.1为什么要有this引用
- 5.2什么是this引用
- 5.3this引用的特证
6.对象的构造及初始化
- 6.1如何初始化对象
- 6.2构造方法
- 6.3构造方法的特性
- 6.4默认初始化
7.private实现封装
8.static成员
- 8.1static修饰成员变量
- 8.2 static修饰成员方法
9.代码块
- 9.1 代码块概念以及分类
- 9.2普通代码块
- 9.3 构造代码块
- 9.4静态代码块
- 代码块注意事项
10.对象的打印

1.什么是面向对象？

以做饭举例
按照每个步骤依次进行的就是面向过程
面向过程形式的做饭注重的是做饭的过程

而我们去找个厨师，让他包揽整个做饭的步骤，我们只需要提供基础的内容就可以，厨师做饭是为了给我服务的，所以他面向的对象是我
面向对象方式来进行处理，就不关注洗做饭的过程

2.类 2.1认识一下类

在java中定义类时需要用到class关键字

语法格式：

// 创建类
class 类名{
field; // 字段(属性) 或者 成员变量
method; // 行为 或者 成员方法
}

class为定义类的关键字
类中的属性是用来描述类的，也被称为成员变量
类中的行为是用来说明类有哪些功能的，也被称为成员方法

2.2类的定义格式

class Person {
    //成员变量
    String name;
    int age;
    //方法-》行为
    public void eat(){
        System.out.println(name+"正在吃饭");
    }
    public void sleep(){
        System.out.println(name+"正在睡觉");
    }
    public void play(){
        System.out.println(name+"正在玩");
    }
}

注意事项：

类名注意采用大驼峰定义
成员前写法统一为public.
此处写的方法不带 static 关键字.

2.3类要注意的问题

public修饰的类必须要和文件名相同，不然不能加public
如果硬要加public就要去src新建一个文件

注意事项：

一般一个文件当中只定义一个类
main方法所在的类一般要使用public修饰
public修饰的类必须要和文件名相同
不要轻易去修改public修饰的类的名称，如果要修改，通过开发工具修改

3.类的实例化

定义了一个类，就相当于在计算机中定义了一种新的类型
用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。

public static void main(String[] args) {
        Person person1 = new Person();
        person1.name="张三";
        person1.age=18;
        person1.eat();

        Person person2 = new Person();
        person2.name="李四";
        person2.age=20;
        person2.sleep();
    }

注意事项:

new 关键字用于创建一个对象的实例.
使用 . 来访问对象中的属性和方法.
同一个类可以创建对个实例.

4.类和对象（重点）

类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员.
类是一种自定义的类型，可以用来定义变量.
一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量
打个比方，类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图
只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

5.this引用 5.1为什么要有this引用

class Date {
    public int year;
    public int month;
    public int day;

    public void setDay(int y, int m, int d) {
        year = y;
        month = m;
        day = d;
    }

    public void printDate() {
        System.out.println(year + "/" + month + "/" + day);
    }
}

public class TestDemo {
    public static void main(String[] args) {
        // 构造三个日期类型的对象 d1 d2 d3
        Date d1 = new Date();
        Date d2 = new Date();
        Date d3 = new Date();
        // 对d1，d2，d3的日期设置
        d1.setDay(2022,4,15);
        d2.setDay(2022,4,16);
        d3.setDay(2022,4,17);
        // 打印日期中的内容
        d1.printDate();
        d2.printDate();
        d3.printDate();
    }
}

在main方法中利用Date这个类创建了三个对象，然后分别赋值输出

但有个问题

形参名不小心与成员变量名相同：
假如我将类中的setDay方法改成如下，那方法知道那个是成员变量那个是形参名吗，到最后打印就会出问题，如果要区分那就需要this引用了

public void setDay(int year, int month, int day){
	year = year;
	month = month;
	day = day;
}

5.2什么是this引用

this本质上是一个引用，this引用指向当前对象，在类中成员方法可以调用成员变量，而为了更加确切的表明，在这个方法中的这个变量指的是类中的成员变量，我们就需要加上this去标识

1.调用当前对象的成员变量
下面的代码中，this引用就代表d引用指向的对象，d.setDay也就让this知道它应该指向和d一样的对象

class Date {
    public int year;
    public int month;
    public int day;

    public void setDay(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
}
public static void main(String[] args) {
	Date d = new Date();
	d.setDay(2020,9,15);
	d.printDate();
}

这样我们修改后就可以正常打印了

2.this调用当前对象的成员方法
这样下面的代码this就能自己打印信息了

3.this调用当前对象的其他构造方法
下面会讲

5.3this引用的特证

this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型
this只能在"成员方法"中使用
在"成员方法"中，this只能引用当前对象，不能再引用其他对象

6.对象的构造及初始化 6.1如何初始化对象

如果没有初始化一个局部变量，那么会报错

public static void main(String[] args) {
	int a;
	System.out.println(a);
}
// Error:(26, 28) java: 可能尚未初始化变量a

初始化对象需要使用构造方法

public static void main(String[] args) {
	Date d = new Date();//这就是构造方法
	d.printDate();
	d.setDate(2021,6,9);
	d.printDate();
}
// 代码可以正常通过编译

有两个问题

1.如果每次创建完对象初始化都需要调用成员方法，是不是很麻烦
2.局部变量必须初始化，为什么对象中的成员变量不初始化可以使用

6.2构造方法

构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次

public class Date {
	public int year;
	public int month;
	public int day;
	// 构造方法：
	// 名字与类名相同，没有返回值类型，设置为void也不行
	// 一般情况下使用public修饰
	// 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
	public Date(int year, int month, int day){
		this.year = year;
		this.month = month;
		this.day = day;
		System.out.println("Date(int,int,int)方法被调用了");
	}
	public void printDate(){
		System.out.println(year + "-" + month + "-" + day);
	}
	public static void main(String[] args) {
		// 此处创建了一个Date类型的对象，并没有显式调用构造方法
		Date d = new Date(2021,6,9); // 输出Date(int,int,int)方法被调用了
		d.printDate(); // 2021-6-9
	}
}

这样每次创建对象时，只需要在构造方法里放入一些初识值就可以相当于初识化对象了

注意：构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间

6.3构造方法的特性

名字必须与类名相同
没有返回值类型，设置为void也不行
创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)
构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)

public class Date {
	public int year;
	public int month;
	public int day;
	// 无参构造方法
	public Date(){
	this.year = 1900;
	this.month = 1;
	this.day = 1;
	}
	// 带有三个参数的构造方法
	public Date(int year, int month, int day) {
		this.year = year;
		this.month = month;
		this.day = day;
	}
	public void printDate(){
		System.out.println(year + "-" + month + "-" + day);
	}
}

上述两个构造方法：名字相同，参数列表不同，因此构成了方法重载。

如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。

public class Date {
	public int year;
	public int month;
	public int day;
	public void printDate(){
		System.out.println(year + "-" + month + "-" + day);
	}
}
	public static void main(String[] args) {
		Date d = new Date();
		d.printDate();
	}

上述Date类中，没有定义任何构造方法，编译器会默认生成一个不带参数的构造方法。
注意：一旦用户定义，编译器则不再生成。
所以要想好要不要定义构造方法

public class Date {
	public int year;
	public int month;
	public int day;
	public Date(int year, int month, int day) {
	this.year = year;
	this.month = month;
	this.day = day;
	}
	public void printDate(){
		System.out.println(year + "-" + month + "-" + day);
	}
	public static void main(String[] args) {
	// 如果编译器会生成，则生成的构造方法一定是无参的
	// 则此处创建对象是可以通过编译的
	// 但实际情况是：编译期报错
	Date d = new Date();
	d.printDate();
}

构造方法中，可以通过this调用其他构造方法来简化代码

public class Date {
	public int year;
	public int month;
	public int day;
	// 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复
	// 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
	// 但是this(1900,1,1);必须是构造方法中第一条语句
	public Date(){
		//System.out.println(year); 注释取消掉，编译会失败
		this(1900, 1, 1);
		//this.year = 1900;
		//this.month = 1;
	/	/this.day = 1;
	}
	// 带有三个参数的构造方法
	public Date(int year, int month, int day) {
		this.year = year;
		this.month = month;
		this.day = day;
	}
}

this调用当前对象的其他构造对象是this()，但是你要知道，你不能在当前构造对象中调用自己，这样会死循环无限递归下去，需要有两个及以上的构造方法才能调用，也要知道调用完后还会回到当前的构造方法继续执行，并且this()必须放在方法中的第一行，如果有多个this()那就只能选择一个

注意：

this(…)必须是构造方法中第一条语句
不能形成环

public Date(){
	this(1900,1,1);
}
public Date(int year, int month, int day) {
	this();
}

6.4默认初始化

在6.1中提出了一个问题，为什么局部变量使用的时候必须初始化，而成员变量不需要呢
要搞清楚这个过程，就需要知道 new 关键字背后所发生的一些事情：

Date d = new Date(2022,5,2);

在程序层面只是简单的一条语句，在JVM层面需要做好多事情，下面简单介绍下：

检测对象对应的类是否加载了，如果没有加载则加载
为对象分配内存空间
处理并发安全问题
比如：多个线程同时申请对象，JVM要保证给对象分配的空间不冲突
初始化所分配的空间
即：对象空间被申请好之后，对象中包含的成员已经设置好了初始值，比如：
设置对象头信息
调用构造方法，给对象中各个成员赋值

7.private实现封装

private/ public 这两个关键字表示 “访问权限控制” .

被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用.
被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用.

也就是说被private修饰后只能在类中使用被修饰的成员变量或者方法

直接使用 public

class Person {
	public String name = "张三";
	public int age = 18;
}
class Test {
	public static void main(String[] args) {
		Person person = new Person();
		System.out.println("我叫" + person.name + ", 今年" + person.age + "岁");
	}
}
// 执行结果
我叫张三, 今年18岁

在这里插入代码片

这样的代码导致类的使用者(main方法的代码)必须要了解 Person 类内部的实现, 才能够使用这个类. 学习成本较高
一旦类的实现者修改了代码(例如把 name 改成 myName), 那么类的使用者就需要大规模的修改自己的代码, 维护成本较高.

class Person {
	private String name = "张三";
	private int age = 18;
	public void show() {
		System.out.println("我叫" + name + ", 今年" + age + "岁");
	}
}
class Test {
	public static void main(String[] args) {
		Person person = new Person();
		person.show();
	}
}
// 执行结果
我叫张三, 今年18岁

此时字段已经使用 private 来修饰. 类的调用者(main方法中)不能直接使用. 而需要借助 show 方法. 此时类的使用者就不必了解 Person 类的实现细节.
同时如果类的实现者修改了字段的名字, 类的调用者不需要做出任何修改(类的调用者根本访问不到 name, age这样的字段).

注意事项

private 不光能修饰字段, 也能修饰方法
通常情况下我们会把字段设为 private 属性, 但是方法是否需要设为 public, 就需要视具体情形而定. 一般我们希
望一个类只提供 “必要的” public 方法, 而不应该是把所有的方法都无脑设为 public.

8.static成员 8.1static修饰成员变量

在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的

静态成员也被称之为类变量

访问静态成员变量的语法格式

类名.静态成员变量

【静态成员变量特性】

不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
类变量存储在方法区当中
生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

class Student{
	public String name;
	public String gender;
	public int age;
	public double score;
	public static String classRoom = "317";
}

public static void main(String[] args) {
	// 静态成员变量可以直接通过类名访问
	System.out.println(Student.classRoom);
	Student s1 = new Student("Li leilei", "男", 18, 3.8);
	Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
	Student s3 = new Student("Jim", "男", 18, 2.6);
	// 也可以通过对象访问：但是classRoom是三个对象共享的
	System.out.println(s1.classRoom);
	System.out.println(s2.classRoom);
	System.out.println(s3.classRoom);
}

static修饰的静态成员变量/类变量不能在方法中定义
static定义的变量是类变量，属于类

8.2 static修饰成员方法

Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的

成员方法可以调用静态成员变量和普通成员变量
静态方法只能调用静态成员变量

成员方法可以调用静态方法
静态方法不能调用成员方法

【静态方法特性】

不属于某个具体的对象，是类方法
可以通过对象调用，也可以通过类名.静态方法名(…)方式调用，更推荐使用后者
静态方法是存储在方法区的
不能在静态方法中访问任何非静态成员变量

public int age;

public static String ageUp(){
	age += 1;
	return age;
}
// 编译失败：Error:(35, 9) java: 无法从静态上下文中引用非静态 变量 age

静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用，但非静态的方法可以调用静态的方法

9.代码块 9.1 代码块概念以及分类

使用{} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：

普通代码块
构造块
静态块
同步代码块（多线程时再去学习）

9.2普通代码块

普通代码块：定义在方法中的代码块

public class Main{
	public static void main(String[] args) {
	{ //直接使用{}定义，普通方法块
		int x = 10 ;
		System.out.println("x1 = " +x);
	}
	int x = 100 ;
	System.out.println("x2 = " +x);
	}
}
// 执行结果
x1 = 10
x2 = 100

这种用法很少见

9.3 构造代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量

lass Person{
    String name;

    {
        System.out.println("实例代码块");
    }
	//实例代码块
    static {
        System.out.println("静态代码块");
    }

    Person(){
        System.out.println("创建成功");
    }
}


public class TestDemo {
    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("==========");
        Person person2 = new Person();
    }
}

9.4静态代码块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量

lass Person{
    String name;

    {
        System.out.println("实例代码块");
    }
	//静态代码块
    static {
        System.out.println("静态代码块");
    }

    Person(){
        System.out.println("创建成功");
    }
}


public class TestDemo {
    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("==========");
        Person person2 = new Person();
    }
}

在实行顺序上是先执行静态代码块，然后是实例代码块，最后是构造方法，并且静态代码块只能执行一次！！

代码块注意事项

注意事项

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

10.对象的打印

当我们调用

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


public static void main(String[] args) {
	Person person = new Person("Jim","男", 18);
	System.out.println(person);
	}
}
// 打印结果：day20210829.Person@1b6d3586

如果想要默认打印对象中的属性该如何处理呢？答案：在对应的类中重写toString方法即可。
因为在println调用时源码调用了toString，我们在类重现toString，仅限于println这个类中的内容时，才会出现修改的内容，哪怕改一个输出的类都不会发生其他改变

public class Person {
	String name;
	String gender;
	int age;
	public Person(String name, String gender, int age) {
		this.name = name;
		this.gender = gender;
		this.age = age;
	}
@Override
	public String toString() {
		return "[" + name + "," + gender + "," + age + "]";
	}
public static void main(String[] args) {
	Person person = new Person("Niu","男", 18);
	System.out.println(person);
	}
}
// 输出结果：[Niu,男,18]

JavaSE：类与对象

Java相关栏目本月热门文章