目录
1. 面向对象的初步认知
1.1 什么是面向对象
Java是一门纯面向对象的语言(Object Oriented Program,简称OOP),在面向对象的世界里,一切皆为对象。面向对象是解决问题的一种思想,主要依靠对象之间的交互完成一件事情。用面向对象的思想来设计程序,更符合人们对事物的认知,对于大型程序的设计、扩展以及维护都非常友好。
1.2 面向对象与面向过程
1. 传统洗衣服过程
传统的方式:
传统的方式:注重的是洗衣服的过程,少了一个环节可能都不行。
而且不同衣服洗的方式,时间长度,拧干方式都不同,处理起来就比较麻烦。如果将来要洗鞋子,那就是另一种方式。
按照该种方式来写代码,将来扩展或者维护起来会比较麻烦。
2. 现代洗衣服过程
以面向对象方式来进行处理,就不关注洗衣服的过程,具体洗衣机是怎么来洗衣服,如何来甩干的,用户不用去关心,只需要将衣服放进洗衣机,导入洗衣粉,启动开关即可,通过对象之间的交互来完成的。
注意:面向过程和面向对象并不是一门语言,而是解决问题的方法,没有那个好坏之分,都有其专门的应用场景。
2. 类定义和使用
那么对象从何而来?
比如张三这个人, 就是一个对象. 我们就可以用一些口头语言去描述张三的形象特征, 也就是描述张三这个对象. 于是我们也可以通过代码来描述张三这个人.
2.1 认识类
class Person {
// 描述 人的属性
public int age; // 年龄
public String name; // 姓名
// 描述 人的行为
public void eat() {
System.out.println("吃饭~ ");
}
}
以上代码简单的素描了一下人的属性, 但注意这个代码并不等于有了一个"真实的张三".
那么描述一个对象我们就会通过这样的一个"类"去描述.
类是用来对一个实体(对象)来进行描述的,主要描述该实体(对象)具有哪些属性(外观尺寸等),哪些功能(用来干啥),描述完成后计算机就可以识别了。
比如:洗衣机,它是一个品牌,在Java中可以将其看成是一个类别。
属性:产品品牌,型号,产品重量,外观尺寸,颜色...
功能:洗衣,烘干、定时....
2.2 类的定义格式
一个类由两部分组成: 属性 + 行为 (也叫 成员属性 + 成员方法)
在java中定义类时需要用到class关键字: class 类名{}
(注: 类名使用大驼峰)
// 创建洗衣机类
class WashMachine {
// 属性[字段] -> 成员属性
public String brand; // 品牌
public String type; // 型号
public double weight; // 重量
public double length; // 长
public double width; // 宽
public double height; // 高
public String color; // 颜色
// 行为[方法] -> 成员方法
public void washClothes(){ // 洗衣服
System.out.println("洗衣功能");
}
public void dryClothes(){ // 脱水
System.out.println("脱水功能");
}
public void setTime(){ // 定时
System.out.println("定时功能");
}
}
注意事项:
1. 类名使用大驼峰命名; 方法名/变量使用小驼峰命名.
2. 成员前写法 这里 统一为public.
3. 这里 写的方法不带static关键字.
定义 狗 这个类.
class Dog {
// 成员变量
public String name;
public String color;
// 行为
public void barks() {
System.out.println(name + "汪汪叫!");
}
public void wag() {
System.out.println(name + "摇尾巴!");
}
}
注意事项:
1. 一个Java文件一般只定义一个类
2. main方法所在的类一般要使用public修饰
3. public修饰的类必须要和文件名相同
4. 不要轻易去修改public修饰的类的名称,如果要修改,通过开发工具修改
3. 类的实例化(如何产生对象)
有了类之后, 应该怎么用? 应该怎么样拥有一个对象?
3.1 什么是实例化
我们现在已经有了一个类, 但是它不是一个具体的实体, 比如上文中的Dog类, 它并不是一个具体的狗, 只是一个类似于模板/图纸一样的东西, 那么要想让这个Dog成为"真正的狗", 那怎么办?我们来看.
Dog dog = new Dog();
这句代码我们称作: 实例化一个Dog对象.
那么只要new一个Dog, 就真正意义上有一只狗了. 这就是由类变成一个真正的实体.
定义了一个类,就相当于在计算机中定义了一种新的类型.
就像int a = 10;
,类型 变量 = 值;
, 我们定义的类Dog也叫做类型, 是我们自己定义的一种类型,类型 变量 = 实例化一个对象;
与int,double类似,只不过int和double是java语言自带的内置类型,而类是用户自定义了一个新的类型. 类(一种新定义的类型)有了这些自定义的类型之后,就可以使用这些类来定义实例(或者称为对象)。
用类类型创建对象的过程,称为类的实例化,在java中采用new关键字,配合类名来实例化对象。
3.2 访问对象的成员
那么new了对象后, 类中的属性怎么访问?
通过.
操作符
dog.name = "来福";
dog.color = "黑色";
于是:
System.out.println(dog.name);
System.out.println(dog.color);
当给对象赋值了之后, 就可以通过 引用.方法
来访问方法.
dog.barks();
dog.wag();
3.3 类和对象的说明
1. 类只是一个模型一样的东西,用来对一个实体进行描述,限定了类有哪些成员.
2. 类是一种自定义的类型,可以用来定义变量.
3. 一个类可以实例化出多个对象,实例化出的对象 占用实际的物理空间,存储类成员变量
4. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子,类就像是设计图,只设计出需要什么东西,但是并没有实体的建筑存在,同样类也只是一个设计,实例化出的对象才能实际存储数据,占用物理空间
代码示例: 通过一个类可以实例化无数个对象.
Dog dog2 = new Dog();
dog2.name = "小灰";
dog2.color = "灰色";
Dog dog3 = new Dog();
Dog dog4 = new Dog();
4. this引用
4.1 为什么要有this引用
先看一个日期类的例子:
public class TestDate {
public int year; // 年
public int month; // 月
public int day; // 日
public void setDate(int y, int m, int d) {
year = y;
month = m;
day = d;
}
public void printDate() {
System.out.println(year + "-" + month + "-" + day);
}
public static void main1(String[] args) {
TestDate testDate = new TestDate();
System.out.println("fda");
}
}
此时打断点,可以看到:
在testDate中yeah, month, day都为0.
我们现在要给它们赋值, 于是就要通过testDate这个引用单独的去访问成员属性.
public static void main(String[] args) {
TestDate testDate = new TestDate();
testDate.year = 2023;
testDate.month = 10;
testDate.day = 26;
System.out.println("fda");
}
此时再运行Debug:
可以看到, 三个成员属性被赋值了.
也可以通过printDate()
访问三个成员属性:
如果不是在main中一个一个赋值的, 那么就可以调用setDate()
传入参数进行赋值.
我们进行Debug, 进入setDate()
:
可以看到, 现在y, m, d这些形参的值是有的, 然后yeah, month, day这些默认都是0, 往下走会发现会被赋值.
然后再运行, 打断点的这一行代码就执行完毕了.
这里要明白, yeah, month, day都是这个testDate对象里面的.
对于前面的代码, 如果我们把setDate()
的形参变一下:
public void setDate(int year, int month, int day) {
year = year;
month = month;
day = day;
}
运行之后会看到, 结果变成了都是0, 三个成员属性没有被赋值.
原因就在于:
局部变量优先原则.
也就是说, 在setDate()
中, 它认为yeah, month, day都是局部变量.
相当于在这里只是形参自己给自己赋值了, 所以它根本没有赋值到成员变量中.
那么怎么样才能赋值到成员变量中?
这里就要使用一个东西叫做this
关键字.
把this
加到setDate()
中就可以了
public void setDate(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
可以看到, 加上this之后, 运行结果就没有什么问题了.
为什么加上this就可以了, this又代表什么?
再来看下面这个例子:
public static void main(String[] args) {
TestDate testDate1 = new TestDate();
TestDate testDate2 = new TestDate();
TestDate testDate3 = new TestDate();
testDate1.setDate(2023, 10, 26);
testDate2.setDate(2024, 10, 26);
testDate3.setDate(2025, 10, 26);
testDate1.printDate();
testDate2.printDate();
testDate3.printDate();
}
执行结果:
并且问题是在setDate中就算没有加this, 结果也是一样的.
三个对象都在调用setDate和printDate函数,但是这两个函数中没有任何有关对象的说明,setDate和
printDate函数如何知道打印的是那个对象的数据呢?
4.2 什么是this引用
this引用指向当前对象(成员方法运行时调用该成员方法的对象),在成员方法中所有成员变量的操作,都是通过该引用去访问。只不过所有的操作对用户是透明的,即用户不需要来传递,编译器自动完成。
public 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 void printDate(){
System.out.println(this.year + "/" + this.month + "/" + this.day);
}
}
注意:this引用的是调用成员方法的对象。
public static void main(String[] args) {
Date d = new Date();
d.setDay(2020,9,15);
d.printDate();
}
this有三种使用方法:
this.成员变量
this.访问成员方法
this();访问构造方法
第三个具体后续讲解.
4.3 this引用的特性
1. this的类型:对应类类型引用,即哪个对象调用就是哪个对象的引用类型
2. this只能在"成员方法"中使用
3. 在"成员方法"中,this只能引用当前对象,不能再引用其他对象
4. this是“成员方法”第一个隐藏的参数,编译器会自动传递,在成员方法执行时,编译器会负责将调用成员方法对象的引用传递给该成员方法,this负责来接收
在代码层面来简单演示--->注意:下图右侧中的Date类也是可以通过编译的
4.4 练习
写一个学生类 有姓名 年龄 等属性, 然后通过一个方法设置这些属性的值。其次通过写2个方法,在其中一个方法当中,使用this调用另一个方法.
public class Student {
public String name;
public int age;
public void setStudent(String name, int age) {
this.name = name;
this.age = age;
}
public void print() {
System.out.println(this.name + " => " + this.age);
}
public static void main(String[] args) {
Student student = new Student();
student.setStudent("Zhangsan", 18);
student.print();
}
}
5. 对象的构造及初始化
5.1 如何初始化对象
5.1.1 默认初始化
通过new可以实例化一个对象, 在对象中有很多的成员, 如果是方法中的一个局部变量, 我们知道没有初始化时一定会报错, 但是如果是对象, 却是能通过编译的.
public static void main(String[] args) {
Student student = new Student();
// 没有给成员变量赋值, 直接访问成员变量, 不会报错, 因为它是一个引用变量
System.out.println(student.name);
}
不会报错的原因就在于默认初始化. 也就是没有给成员变量赋值的时候, 它们有自己的默认值, 这就是默认初始化.
5.1.2 就地初始化
写类的时候直接给成员变量赋值.
public class Student {
public String name = "Zhangsan";
public int age = 18;
// ..
}
然而这种写法不好, 因为类本身就是一个模板, 对于上例来说不是所有的学生都叫做yy, 年龄都是18.
就地初始化的使用取决于代码的需求.
不同数据类型作为成员变量时所对应的默认值如下表:
数据类型 | 默认值 |
---|---|
byte | 0 |
char | '\u0000' |
short | 0 |
int | 0 |
long | 0L |
boolean | false |
float | 0.0f |
double | 0.0 |
reference | null |
那么除了setXXX方法还有其他的方式可以用于对象的初始化
5.2 构造方法
通过构造方法给对象中的成员进行初始化.
构造方法(也称为构造器)是一个特殊的成员方法,没有返回值, 方法名与类名相同,在创建对象时,由编译器自动调用,并且在整个对象的生命周期内只调用一次。
// 对于 Student类
Student() {
System.out.println("不带参数的构造方法");
}
// 可以通过构造方法传参并对成员变量赋值
Student(String name,int age) {
System.out.println("带2个参数的构造方法");
this.name = name;
this.age = age;
}
虽然构造方法写好了, 但是构造方法如何被调用?
我们运行代码:
可以看到, 我们写的Student()方法被调用了. 并且可以知道, 这个方法是在Student student = new Student();
这一行代码被调用的.
构造方法的调用是在new后的Student()
. 我们通过new实例化对象, 在实例化对象的时候一定会调用构造方法.
在前面我们没有写两个Student()
构造方法的时候, 并没有编译报错, Student student = new Student();
也没有提供参数? 为什么说一定会调用构造方法?
当我们没有主动提供构造方法的时候, 编译器会默认帮我们提供一个不带参数的构造方法.
所以理论上来说, 我们在Student student = new Student();
什么都没写, 实际上会有默认调用Student()
的存在. 那么只要我们主动写了, 就会调用我们写的构造方法.
注: 一般我们写构造方法会在前面都加上public, 具体原因后续说.
// 对于 Student类
public Student() {
System.out.println("不带参数的构造方法");
}
// 可以通过构造方法传参并对成员变量赋值
public Student(String name,int age) {
System.out.println("带2个参数的构造方法");
this.name = name;
this.age = age;
}
那么我们也可以调用带两个参数的构造方法, 在main中加上:
Student student2 = new Student("Sun",18);
可以看到, 不带参数的和带2个参数的都已经被打印.
由此可以说明, 在实例化对象的时候才会调用构造方法, 而且在调用构造方法的时候可以传参, 对成员属性进行赋值. 所以要想实例化对象, 就一定要调用构造方法.
于是我们可以理解为, 当构造方法调用完成之后, 对象才实际意义上的产生了.
同时我们可以看到, 构造方法是可以被重载的,
小结: 构造方法的特性:
1. 名字必须与类名相同
2. 没有返回值类型,设置为void也不行
3. 创建对象时由编译器自动调用,并且在对象的生命周期内只调用一次(相当于人的出生,每个人只能出生一次)
4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)
5. 如果用户没有显式定义,编译器会生成一份默认的构造方法,生成的默认构造方法一定是无参的。
注意:一旦用户定义,编译器则不再生成。
6. 构造方法中,可以通过this调用其他构造方法来简化代码
注意:
this(...)必须是构造方法中第一条语句
不能形成环
7. 绝大多数情况下使用public来修饰,特殊场景下会被private修饰(后序讲单例模式时会遇到)
// 关于构造方法中的 this 的使用
public Student() {
// 调用 本类当中 其他的构造方法
this("zhangsan", 23); // 走到这里, 代码会调到Student(name, age)方法执行
System.out.println("不带参数的构造方法");
}