理解Java类的构成与应用-优快云博客

本文链接：https://blog.youkuaiyun.com/x775229836/article/details/18774817

本文详细介绍了Java类的基本组成部分，包括成员变量、构造器和成员方法，并通过实例展示了如何定义和使用类。此外，文章还阐述了局部变量与成员变量的作用域，以及构造器的重载和this关键字的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

详细研究如何去定义一个类。

1. 一个类由三个部分组成。这三个部分并不是全部必须的。

在编写类之前，要先设计类：数据(用成员变量来表示)，和对这些数据的操作(用成员方法来表示)。
class 类名{
	//1.成员变量

	//3.构造器(构造方法) -> 其中一个重要作用，是对成员变量进行初始化

	//2.成员方法 —> 用来操作本类中的成员变量/或者像一个普通的方法(函数)一样
}
2.成员变量。

也叫"字段"。它的定义和一般变量是一样的。
成员变量也叫"实例变量"，如果不明确赋值的话，会自带一个默认的值。

成员变量：遵循标识符的命名规则；驼峰命名法，首字母小写：望文生义。
class C{
	byte byteVar;
	byte shortVar;
	int intVar;
	long longVar;
	float floatVar;
	double doubleVar;
	char charVar;
	boolean booleanVar;
	String string;
}

public class Demo{
	public static void main(String[] args){
		C c = new C();
		System.out.println(c.byteVar);
		System.out.println(c.shortVar);
		System.out.println(c.intVar);
		System.out.println(c.longVar);
		System.out.println(c.floatVar);
		System.out.println(c.doubleVar);
		System.out.println(c.charVar);
		System.out.println(c.booleanVar);
		System.out.println(c.string);
	}
}
3.成员方法。
语法格式
void |数据类型 方法名称(参数列表){
	//方法体
}
3.1方法命名：遵循标识符的命名规则；驼峰命名法，首字母小写：望文生义。方法的命名：动词+名词。

3.2方法名称后面，必须紧跟一对小括号。小括号内，可以有参数(有1个或多个。如果有多个的话，称为参数列表，用逗号

     分隔)，也可以没有参数。

3.3方法命名前，要指定该方法返回数据类型。(既可以是原始数据类型，也可以是自定义数据类型，还可以是数组)。

     如果该方法的代码调用后，不要求有返回值，那么，必须用void关键字指明。

     如果该方法的代码调用后，有返回值，那么，在方法体内(花括号内)，必须要有"return 返回数据"语句，并且返回数据的类型，要和方法名前指定的数据类型保持一

     致。

3.4对方法的调用：通过方法名称(后跟小括号)的方式调用。

3.5方法声明中的参数，为局部变量。局部变量和成员变量的区别：

    局部变量的生命周期(变量的作用域)，仅限于从它声明开始，到所在方法结束。

3.6参数传递中的"值传递"和"引用传递"。

3.7当一个类中有多个同名的方法、但方法签名不同时，称为"方法重载"，又叫"动态方法调用"。

     方法签名 ->方法签名 = 方法名称 + 参数数量和类型/顺序。
//定义一个小计算器类
class Calculate{
	//加法运算
	int add(int number1, int number2){	//这里定义的参数称为"形参"
		int result = number1 + number2;
		return result;
	}
	//对两个整数值进行交换
	void swap(int number1, int number2){
		int temp;
		temp = number1;
		number1 = number2;
		number2 = temp;
	}
	void swap(int[] numbers){
		int temp;
		temp = number[0];
		number[0] = number[1];
		number[1] = temp;
	}
}

public class Demo{
	public static void main(String[] args){
		int a = 3, b = 5;

		Calculate cal = new Calculate();

		int addResult = cal.add(a, b);	//这里传进去的a和b成称为"实参"
		System.out.println(addResult);
		System.out.println("交换方法调用前：a=" + a + ",b=" + b);	//a = 3,b = 5
		cal.swap(a, b);
		System.out.println("交换方法调用后：a=" + a + ",b=" + b);	//a = ?,b = ? -> 值传递
		int[] intArray = {3, 5};
		System.out.println("交换方法调用前：" + intArray[0] + "," + intArray[1]);
		cal.swap(intArray);
		System.out.println("交换方法调用后：" + intArray[0] + "," + intArray[1]);//a = ?,b = ? -> 引用传递
	}
}
//需求：保存多个学生的信息。（使用成员方法） 

class Student{ 
	//成员变量
    String stuName;     //学号字段  
    int stuId;          //姓名字段  
    int stuAge;         //年龄字段  

	//成员方法
	//自我介绍
	void selfinfo(){
		System.out.println("我叫" + stuName + ",我的学号是" + stuId + ",我的年龄是" + stuAge);
	}
}  
  
public class Demo{  
    public static void main(String[] args){  
        //1.定义一个Student类型的数组，他只能存入Studnet类型的变量  
        Student[] stus = new Student[2];  
  
        //2.创建并保存第一个学生信息  
        Student stu01 = new Student();  
        stu01.stuName = "张三";  
        stu01.stuId =  111;  
        stu01.stuAge = 18;  
        stus[0] = stu01;  
  
        //3.创建并保存第二个学生信息  
        Student stu02 = new Student();  
        stu02.stuName = "李四";  
        stu02.stuId =  222;  
        stu02.stuAge = 19;  
        stus[1] = stu02;  
  
        //for-each遍历数组  
        for(Student stu : stus){  
            System.out.println("学号：" + stu.stuId + "    姓名：" + stu.stuName + "  年龄：" + stu.stuAge);  
        }  
  
        System.out.println("--------------------------------------");  
  
        //普通for循环  
        for(int i = 0;i < stus.length;i++){  
            Student stu = stus[i];  
            //System.out.println("学号：" + stu.stuId + "    姓名：" + stu.stuName + "  年龄：" + stu.stuAge); 
			stu.selfinfo();//对对象中方法的调用
        }
    }
}
3.8 可变参数：参数的数量是可变的。

      1)可变参数，必须是位于参数列表中的最后一个。

      2)可变数量：0、1或多个。

      3)可变数量，是作为数组进行处理的。
//定义一个小计算器类
class Calculate{
	//加法运算
	int add(int... numbers){	//使用可变参数
		int result = 0;
		for(int i=0;i<numbers.length;i++){
			result = result + numbers[i];
		}
		return result;
	}
}

public class Demo{
	public static void main(String[] args){
		

		Calculate cal = new Calculate();

		System.out.println(cal.add());
		System.out.println(cal.add(1));
		System.out.println(cal.add(1,1));
		System.out.println(cal.add(1,1,1));
	}
}
4. 变量的作用域。
4.1 在一个类中，有三个地方可以定义变量(三种变量)：类的字段部分(成员变量)、方法的参数变量(局部变量)、方法内声明的变量(局部变量)。

4.2 如果局部变量和成员变量同名的情况下，局部变量屏蔽成员变量。

4.3 局部变量，它的作用范围，是从声明它的地方开始，到方法的结束。

4.4 成员变量定义的位置不关紧，它的作用域范围总是在整个内部类。

4.5 所以，好的做法是，尽可能的不要让局部变狼与成员变量同名。
class VarScope{
	int number = 0;			//成员变量

	void write(){
		System.out.println(number);
	}

	void write(int number){	//参数变量(局部变量)
		System.out.println(number);
	}

	void writeNumber(){
		System.out.println(number);
		int number = 3;		//局部变量,它的作用范围,是从声明它的地方开始,到方法的结束。
		System.out.println(number);
	}
}

public class Demo{
	public static void main(String[] args){
		VarScope vs = new VarScope();

		vs.write();		//?
		vs.write(5);	//? -> 如果局部变量和成员变量同名的情况下，局部变量屏蔽成员变量
		vs.writeNumber();	//? ?
	}
}
5. this关键字

但是，有的时候，局部变量又最好是和成员变量同名。

在局部变量屏蔽成员变量的情况下，如果想要绕开这种屏蔽，能访问到成员变量，需要使用this关键字。

6. 属性
实际上，属性不是字段。只有提供了get方法的字段，才称为属性。
//什么情况下，局部变量最好和成员变量同名

class Student{
	//成员变量(字段)
	private String stuId;
	private String stuName;
	private int stuAge;

	//set方法：set开头，后跟字段的名字，首字母变成大写
	//这些setter、getter方法，称为"读写器"
	public void setStuId(String stuId){
		this.stuId = stuId;
	}
	//把"get"去掉后面首字母换成小写，叫做"属性"
	//有一个属性叫"stuId"
	public String getStuId(){
		return this.stuId;
	}

	public void setStuName(String stuName){
		this.stuName = stuName;
	}

	//有一个属性叫"stuName"
	public String getStuName(){
		return this.stuName;
	}

	public void setStuAge(int stuAge){
		if(stuAge<18)
			this.stuAge = 18;
		else
			this.stuAge = stuAge;
	}

	//有一个属性叫"stuAge"
	public int getStuAge(){
		return this.stuAge;
	}

	//有一种属性叫"angthing"
	public String getAnything(){
		return "anything";
	}
}

public class Demo{
	public static void main(String[] args){
		Student zhangsan = new Student();
		//zhangsan.StuId="112";
		//zhangsan.StuName="张三";
		//zhangsan.StuAge=18;

		zhangsan.setStuId("111");		
		zhangsan.setStuName("张三");
		zhangsan.setStuAge(18);

		System.out.println(zhangsan.getStuId());
		System.out.println(zhangsan.getStuName());
		System.out.println(zhangsan.getStuAge());
	}
}
7. 构造器
7.1 构造器，也叫构造方法。其名称必须和类名相同，后跟方法的小括号，再后跟方法体花括号。

7.2 构造方法也可以重载。

7.3 构造器的主要作用：对成员变量进行初始化、加载资源、……

7.4 构造器的使用：在创建类的实例对象时，使用new运行符，调用构造器，来创建实例，申请空间。

通过构造实例对象时，传递的构造器参数，来对成员变量进行初始化。
class Student{
	
	//成员变量
	private String stuId;
	private String stuName;
	private int stuAge;

	//构造器(构造方法)
	Student(){
		System.out.println("无参构造器");
	}

	Student(String stuId){
		this.stuId = stuId;
		System.out.println("1个参数构造器");
	}

	Student(String stuId, String stuName){
		this.stuId = stuId;
		this.stuName = stuName;
		System.out.println("2个参数构造器");
	}

	Student(String stuId, String stuName, int stuAge){
		this.stuId = stuId;
		this.stuName = stuName;
		this.stuAge = stuAge;
		System.out.println("3个参数构造器");
	}

	//读写方法：get和set
	//...
}

public class Demo{
	public static void main(String[] args){
		Student stu = new Student(); 

		Student stu01 = new Student("111");
		Student stu02 = new Student("112","张三");
		Student stu03 = new Student("113","李四",18);
	}
}
7.5 通过this关键字调用同一对象中的其他构造器。
class Student{
	
	//成员变量
	private String stuId;
	private String stuName;
	private int stuAge;

	//构造器(构造方法)
	Student(){
		System.out.println("无参构造器");
	}

	Student(String stuId){
		System.out.println(this.stuId);
		this.stuId = stuId;
		System.out.println("1个参数构造器");
		System.out.println(this.stuId);
	}

	Student(String stuId, String stuName){
		this(stuId);	//调用当前对象中带一个参数的构造器
		this.stuName = stuName;
		System.out.println("2个参数构造器");
	}

	Student(String stuId, String stuName, int stuAge){
		this(stuId,stuName);
		if(stuAge < 18)
			this.stuAge = 18;
		else
			this.stuAge = stuAge;
		System.out.println("3个参数构造器");
	}

	//读写方法：get和set
	//...
}

public class Demo{
	public static void main(String[] args){
		Student stu = new Student("111","三");

//		Student stu01 = new Student("111");
//		Student stu02 = new Student("112","张三");
//		Student stu03 = new Student("113","李四",18);
	}
}
7.6 如果在定义类时，不明确制定一个构造器，那么编译器在编译时，会自动的添加一个空的默认的构造器

但是，一旦你指定了一个构造器，那么，编译器就不会再插入默认的构造器了。

类和对象_定义类2