Java面向对象（1）

文章目录

• 系列文章目录
• 前言
• 一、 定义学生类
• 二、同一对象被多个变量引用
• 三、类的封装
• 四、定义有参的构造方法
• 五、构造方法的重载
• 总结

---

前言

本次主要分享目录上提到的知识点，这也是学习对象的开始部分哦。。。

---

一、定义学生类

        学习目标

                1.掌握类定义的方式

                2.掌握如何在类中定义成员变量和成员方法

        需求分析

                在面向对象的思想中最核心就是对象，在程序中创建对象的前提是需要定义一个类。为了让初学者掌握类的定义方式，本案例将设计一个表示学生的类，该类具有表示姓名的属性name和表示年龄的属性age，同时还具有表示说话行为的方法speak()，用于输出学生的姓名和年龄。

        设计思路（实现原理）

                1.使用class关键字定义一个表示学生类型的类，类名为Student。

                2.在Student类中定义两个成员变量name和age，分别用来表示姓名和年龄。其中，name的数据类型为String，变量age的数据类型为int。

                3.在Student类中定义一个表示说话行为的speak()方法，用于输出学生的姓名和年龄。

        案例实现

public class Student {
		String name;
	     int age;
	     void speak() {
	    System.out.println("我的名字是 "+name+"，今年 "+age+"岁");
	    }
}

        案例总结

                1.Java语言严格区分大小写，class和Class是不同的，在定义类时只能使用class关键字

                2.在Student类中，成员变量name是String类型，String表示一个字符串，后面的章节会详细讲解

二、同一对象被多个变量引用

         学习目标

                1.掌握如何创建类的对象

                2.掌握如何使用两个或者多个变量引用同一个实例对象。

        需求分析

                在程序中，一个对象可能在多处使用，这样就可能需要有多个变量来引用这个对象。为了让初学者更好地掌握对象的创建和使用，本案例将基于案例3-1，创建三个学生对象，它们的引用变量分别是s1、s2和s3，首先分别使用s1和s2引用，为name和age赋值，然后调用speak()方法，最后将s2变量赋值给s3， s3也调用speak()方法。

        设计思路（实现原理）

                1.编写Example01类

                2.在main()方法中，创建Student类的第一个对象，其引用变量为s1，使用s1调用name和age变量分别为它们赋值为“张三”和“19”，然后调用speak()方法。

                3.创建Student类的第二个对象，其引用变量为s2，使用s2分别为name和age赋值为“李四”和“20”，然后调用speak()方法。

                4.创建Student类的第三个对象，其引用变量为s3，将s2的值赋给s3，然后使用s3调用speak()方法。

        案例实现

public class Example01 {
public static void main(String [] args) {
			Student s1 = new Student();
			s1.name="张三";
			s1.age=19;
			s1.speak();     
			
			Student s2 = new Student();
			s2.name="李四";
			s2.age=20;
			s2.speak(); 
			
			Student s3 = new Student();
			s3=s2;
			s3.speak();
}
}

        运行结果        

                

        案例总结

                1.Student s3 = s2这句代码的作用是将s2引用的内存地址赋值给s3，换句话说，就是使变量s3和s2引用了同一个Student对象，因此s3.speak()方法和s2.speak()方法打印的结果相同。为了更加深刻地了解这句代码的含义，下面通过一张内存图来演示。

                  

 

                2.可以使用两个或者多个变量引用同一个实例对象，只要通过其中一个变量对该对象的属性进行修改，使用其它引用变量访问时，访问的都是修改后的属性。

三、类的封装

         学习目标

                1.了解为什么要对类进行封装

                2.了解如何实现类的封装

        需求分析

                s1对象的年龄是可以随便赋值的，如果将age的值赋值为-30，显然违背了事实。为了解决这类问题，我们需要对类进行封装，防止外界对类中的成员变量随意访问。为了让初学者更好地掌握类的封装，本案例将使用private关键字对成员变量name和age进行私有化，同时分别提供一个setName(String n)和setAge(int a)方法用于外界的访问，其中setAge(int a)中需要对age进行判断。

        设计思路（实现原理）

                1.编写测试类Example02，将属性age的值设为-30，演示不合理现象。

                2.对Student类进行修改，将name和age属性使用private修饰，然后定义getName()、setName(String n)、getAge()和setAge(int a)四个对外访问name和age的方法。

                3.在setAge(int a)方法中对传入的参数进行检查，如果输入值为负数，则打印出“设置的年龄不合法”，如果不为负数，才将其设置为age属性的值。

                4.对Example02类进行修改，在main()方法中创建Student类的实例对象，通过调用对象的setName(String n)和setAge(int a)方法来设置的name属性和age属性值，并调用speak()方法。

        案例实现

对Student类进行封装，其代码如下

class Student {
	private String name = "张三";
	private int age = 19;
	public String getName() {
		return name;
	}
	public void setName(String n) {
		name = n;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int a) {
		// 对传入的参数进行检查
		if(a < 0){
			System.out.println("设置的年龄不合法");
		}else{
			age = a;
		}
	}
	void speak() {
		System.out.println("我的名字是" + name + "，今年" + age + "岁");
	}
}
public class Example02 {
	public static void main(String[] args) {
		Student s1 = new Student();
		s1.setName("小新");
		s1.setAge(-30);
		s1.speak();
	}
}

        运行结果

        ​​​​​​​        

        案例总结

                 Student的name和age属性使用private关键字修饰为私有后，在Example02类中不能再使用s1.name和s1.age的方式访问这两个属性，只能通过public类型的setName(String n)和setAge(int a)方法进行访问。在上面的代码中，调用setAge(int a)方法时的传入参数为-30，由于参数小于0，会打印出“设置的年龄不合法”，并不会将负数赋值给age属性。由此可见，只要实现了封装就能对外界的访问进行控制，避免对私有变量随意修改而引发问题。

四、定义有参的构造方法

         学习目标

                1.掌握有参构造方法的定义方式

                2.理解系统会自动分配无参构造方法的情况

        需求分析

                如果希望在创建对象的时候直接为其属性赋值，可以定义有参的构造方法。有参构造方法指的是在初始化对象时，接受外部传入的值并赋给对象的属性。为了让初学者掌握有参构造方法的用法，本案例将演示如何使用有参构造方法完成对象属性的初始化。

        设计思路（实现原理）

                1.定义一个Student类，该类有一个age属性，在类中定义一个有参数的构造方法，该参数用于为age属性赋值。

                2.编写一个测试类Example04，在main()方法中通过有参构造方法创建一个对象。

                3.打印该对象age属性的值。

        案例实现

                1.Student类代码

package Mianxiangduixiangshang;

public class Student04 {
	int age;
	public Student04(int mAge) {
		age = mAge;
	}
}

                2.定义Example04类，代码如下所示

package Mianxiangduixiangshang;

public class Example04 {
	public static void main(String[] args) {
		Student04 s1 = new Student04(20);
		System.out.println("age属性的值为:"+s1.age);
	}
}

        运行结果

        ​​​​​​​        ​​​​​​​        

        案例总结

                1、从运行结果可以看出，new Student(20)语句调用了有参的构造方法Student(int mAge)，动态地将20传递给了age属性。和普通方法一样，构造方法中同样可以接收多个参数，只要在使用new关键字创建对象时，传入数量相同和类型一致的参数，就可以自动地调用对应的构造方法。

                2、思考一下：在Example04的main()方法中是否能够使用new Student()创建对象呢？答案是否定的，因为new Student()会调用无参的构造方法，而本案例的Student类中并没有定义无参的构造方法。

有些同学肯定会问，之前的Student类都没有定义无参的构造方法，却能使用new Student()创建对象，本案例为什么不行呢？这是因为一个类中如果没有定义构造方法，系统会默认为其分配一个方法体为空的无参构造方法，而一旦定义了构造方法，系统就不再提供默认的构造方法。本案例中由于我们定义了一个有参的构造方法，所以系统不会默认分配无参的构造方法，此时如果通过new Student()去调用无参的构造方法，程序就会发生错误。

五、构造方法的重载

        

         学习目标

                1.掌握如何在类中定义重载的构造方法

        需求分析

                和普通方法一样，构造方法也可以重载。不同的构造方法，可以为不同的属性进行赋值。本案例将通过创建对象的方式演示不同构造方法的使用方式，并根据构造方法的输出结果对构造方法的重载进行学习。

        设计思路（实现原理）

1.对Student类进行修改，在类中定义三个重载的构造方法，包括无参的构造方法，接收一个String类型参数的构造方法，接收String类型和int类型两个参数的构造方法。

2.编写测试类Example05，在main()方法中，分别使用三个重载的构造方法创建三个Student对象。

案例实现

Student类 代码

package Mianxiangduixiangshang;

public class Student05 {
	public Student05() {
		System.out.println("无参的构造方法");
	}
	public Student05(String name) {
		System.out.println("一个参数的构造方法");
	}
	public Student05(String name, int age) {
		System.out.println("两个参数的构造方法");
	}
}

Example05类，代码：

package Mianxiangduixiangshang;

public class Example05 {
	public static void main(String[] args) {
		Student05 s1 = new Student05();
		Student05 s2 = new Student05("Rose");
		Student05 s3 = new Student05("Rose", 23);
	}
}

        运行结果

        ​​​​​​​        ​​​​​​​        

        案例总结

                一个类中可以定义多个重载的构造方法，在创建对象时，根据传入参数的不同会调用相应的构造方法。

---

 

 

 

总结

对象部分是JAVA基础中比较难的一部分，在这几天我会把面向对象知识点发上来大家一起讨论，相互交流学习。近期我会依次发java面向对象知识点。刚来到CSDN发作品，还望多多关照。友友们可以和我相互关注以下，有关必回呀！！！一起学习，一起进步。明天继续java面向对象(2)。哈哈哈。