一、初识面向对象
Java是一门纯面向对象的语言(OOP),在面向对象的世界里,一切皆为对象。面向对象是解决问题的一种思想,主要依靠对象与对象之间的交互来完成事情。 使用面向对象的思想,对于大型程序的设计、扩展和维护都十分友好。
注意:面向对象并不是一门语言,而是一种解决问题的方法。
在学习类和对象之前,我们需要先记住:对象的产生依赖于类;而类是需要我们自己定义的。
二、类的定义和使用
1.认识类
类是用来对一个实体(对象)进行描述的,对实体进行抽象,主要描述其具备哪些属性(如:颜色、大小等)以及哪些功能。
2.类的定义格式
在Java中需要用到class关键字来定义类,语法格式为:
class ClassName{
// 属性或成员变量
// 行为或成员方法
}
class为定义类的关键字,ClassName为类名,{}中的为类的主体。类的主体中包含的内容称为类的成员。属性是用来描述类的,称为成员属性或成员变量;行为是用来描述类的功能,称为成员方法。
举个例子,我们定义一个洗衣机类:
class WashMachine {
//成员变量
public String brand; //品牌
public double weight; //重量
public double length; //长
public double width; //宽
public double height; //高
public String color; //颜色
//成员方法
public void wash() {
System.out.println("洗衣");
}
public void dry() {
System.out.println("烘干");
}
public void time() {
System.out.println("定时");
}
}
成员属性/成员变量定义在类的里面,方法的外面。
注意:在此处我们先将成员前的访问修饰限定符统一写为public,且不带static关键字。
我们再来尝试定义一个狗类:
class Dog {
//成员属性
public String brand; //品种
public String color; //颜色
public String name; //姓名
public String sex; //性别
public int age; //年龄
//成员方法
public void call() {
System.out.println("汪汪");
}
public void eat() {
System.out.println("吃狗粮");
}
}
在定义类时,我们需要注意:
1.建议一个文件中只定义一个类。
2.由public修饰的类必须要和文件名相同。
3.如果想要修改由public修饰的类的名称,需要通过IDEA去修改(如下图)。
三、类的实例化
定义了一个类,就相当于定义了一种新的类型,与int,double等类似,只不过int,double是Java语言自带的数据类型。当我们定义了一个类之后,就可以使用类来定义对象。
用类 类型创建对象的过程,称为类的实例化。 在Java中通过new关键字和类名来实例化对象。
通过对象的引用(.)访问对象的属性/变量 和方法。
对象的成员属性在没有赋值时,其值为 其数据类型的默认值。
class Dog {
//成员属性
public String brand; //品种
public String color; //颜色
public String name; //姓名
public String sex; //性别
public int age; //年龄
//成员方法
public void call() {
System.out.println(name + "汪汪");
}
public void eat() {
System.out.println(name + "吃狗粮");
}
}
public class Test {
public static void main(String[] args) {
//通过new关键字实例化了一个Dog对象
Dog a = new Dog(); //a就是一个引用,指向了Dog对象
//通过对象的引用访问对象的属性/变量 和方法。
a.name = "小狗1";
a.age = 6;
a.call();
a.eat();
//通过new关键字可以实例化多个对象
Dog b = new Dog();
b.name = "小狗2";
b.age = 6;
b.call();
b.eat();
}
}
通过new关键字可以实例化多个对象,并且会为每一个实例化出的对象都开辟一块内存空间,存储成员变量。
成员属性存储在对象中,而方法存储在方法区。
可以将类想象为一个模型,用来描述实体。有了类才有对象,类是根据现实中存在的实体抽象出来的,而类想要在代码中表示具体的事物,就需要通过new关键字 实例化对象。
四、this引用
我们先来定义一个日期类:
public class Date {
public int year;
public int month;
public int day;
//赋值操作
public void set(int y, int m, int d) {
year = y;
month = m;
day = d;
}
//打印日期
public void print() {
System.out.println("年:" + year + " 月:" + month + " 日:" + day);
}
public static void main(String[] args) {
Date a = new Date();
a.set(2025, 7, 5);
a.print();
Date b = new Date();
a.set(2025, 6, 5);
a.print();
}
}
我们对赋值操作方法的代码进行修改:
public void set(int year, int month, int day) {
year = year;
month = month;
day = day;
}
修改完后,输出的结果并不是我们预期的值。这是因为局部变量优先原则,会导致局部变量自己给自己赋值,结果为局部变量数据类型的默认值。
此时,我们就可以使用this来解决这个问题:
public void set(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
代码的运行结果与我们预期的相符。
1.this引用指向当前对象(当前对象指:成员方法运行时调用该成员方法的对象)。
2.this的类型取决于哪个对象调用,哪个对象调用就是哪个对象的引用类型。
3.this只能在成员方法中使用。
4.this本身 代表的是当前对象的引用。
还可以使用this调用当前对象的方法:
public void set(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
//this调用当前对象的方法
this.print();
}
使用this调用print方法,程序也可以正常运行,且运行结果与我们预期的相符。
五、对象的构造及初始化
1.有关初始化
在学习有关变量的知识时,我们知道:在定义变量时,一定要给变量一个初始值,否则会导致程序报错。但是当我们定义日期类时,并没有给成员变量赋值,程序却能正常运行。这是因为:当成员变量没有被初始化时,编译器会根据变量的数据类型存储其默认值。
2.构造方法
构造方法是一种特殊的方法:其方法名必须和类名相同且没有返回值。
我们定义一个学生类 并以此举例:
class Student {
public String name; //姓名
public int age; //年龄
public String sex; //性别
public void stu() {
System.out.println("学习");
}
//构造方法
public Student() {
System.out.println("不带参数的构造方法");
}
}
public class Test_gz {
public static void main(String[] args) {
Student a = new Student();
}
}
我们实例化一个学生类对象,运行程序,控制台上打印出了"不带参数的构造方法"这句话。
我们也可以编写带有参数的构造方法:
class Student {
public String name; //姓名
public int age; //年龄
public String sex; //性别
public void stu() {
System.out.println("学习");
}
//构造方法
public Student() {
System.out.println("不带参数的构造方法");
}
public Student(String name, int age) {
this.name = name;
this.age = age;
System.out.println("带有2个参数的构造方法");
}
}
public class Test_gz {
public static void main(String[] args) {
Student a = new Student();
Student b = new Student("小王", 20);
}
}
此时,"带有2个参数的构造方法"这句话,因为实例化了一个学生类:b,所以也被打印出来。
在创建对象时,构造方法由编译器自动调用,且在整个对象(如:a、b)的生命周期内只调用一次!只有当调用完成构造方法之后,对象才产生了。
在日期类中,我们并没有编写构造方法,但程序仍能运行,这是因为:当一个类中,没有任何一个构造方法时,编译器会自动提供一个不带参数的构造方法。
但是当一个类中,存在一个带有参数的构造方法时,编译器就不会提供不带参数的构造方法。 在上面这段代码中,如果我们删掉不带参数的构造方法,再次运行程序,程序就会报错!!
我们仔细观察上面这段代码中的两个构造方法,其实可以发现 他们之间构成了方法的重载。即构造方法之间是可以构成方法的重载的!!!
完成一个对象的构造需要先分配内存,再调用合适的构造方法,因此:构造方法的作用就是对 对象中的成员变量进行初始化,但并不负责为对象开辟内存空间。
还可以使用 this() 调用当前类中的其他构造方法,具体调用哪个构造方法由 this() 的参数决定:
public Student() {
//this()
this("小王", 20);
System.out.println("不带参数的构造方法");
}
public Student(String name, int age) {
this.name = name;
this.age = age;
System.out.println("带有2个参数的构造方法");
}
注意:this() 只能在构造方法内部使用!!!且只能在构造方法的第一行使用!!!
构造方法绝大多数情况下都是被public修饰的,在某些特殊场景下也会被private修饰。
3.就地初始化
在定义成员变量时,对其直接进行赋值:
public String name = "小王"; //姓名
public int age = 20; //年龄
public String sex = "男"; //性别
但并不推荐这种初始化方式。
未完待续…