深入理解Java的类与对象-优快云博客

本文链接：https://blog.youkuaiyun.com/A135LMZ/article/details/101200434

本文详细介绍了Java中的类和对象，包括对象的属性和方法、类与对象的关系、面向对象语言的概念，以及如何定义和使用类。此外，讲解了类的方法，包括无参方法和带参数的方法，以及变量的作用域、javadoc注释的使用。文章还涵盖了包的使用，字符串的处理，如长度、比较和使用StringBuffer类进行操作。

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

十一章.类和对象

1.1对象

Java是一种面对对象的编程语言,因此我们要学会用面向对象的思想考虑问题和编程思想,现实世界中客观的任何事物都可以看做对象,其实每一个对象都有自己的特征,包括静态特征和动态特征…静态特征是可以用某些数据来描述的特征,动态特征是对象所表现的行为或对象所具有的功能,如图所示:

对象	静态特征	静态特征的值	动态特征
"顾客"对象	姓名	张浩
张浩	年龄	20	购买商品
	体重	60kg
"收银员"对象	员工名	10001	收款
李明	姓名	李明
	部门	财务部	打印菜单

通过表格我们可以看出,不同类别的对象具有不同的静态特征和动态特征。

对象的属性和方法:

在面向对象的编程思想中，把对象的静态特征和动态特征分为对象的属性和方法，例如，在上面的例子中，“顾客”

对象有一个属性是姓名，属性值是“张浩”，而方法是用来描述对象动态特征（行为）的一个动作序列。

对象：用来描述客观事物的一个实体，由一组属性和方法构成。

封装：

就是把一个事物包装起来，并尽可能的隐藏内部细节。

1.2类

类和对象的关系：

类和对象的关系就是抽象和具体的关系，类是对象的抽象，对象是类的实例。

插图片：：：：：：：“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“’‘

类是对象的类型：

我们以前学过了很多数据类型，如整型（int),双精度浮点型（double),字符型（char)，那么，如果想描述顾客“张浩”，他的数据类型又是什么，是字符型还是字符串类型？其实都不是，“张浩”的类型就是“顾客”，也就是说类就是对象的类型。

1.3面向对象的语言

在面向对象程序设计中,类是程序的基本单位,java是完全面向对象的编程语言,所有程序都是以类为组织单元的.

示例1:

public class HelloWorld{
	public static void main (String [] args){
		system.out.println("HelloWorld");
	}
}

示例1,程序框架最外层的作用就是定义了一个类Hello word,而Hello word就是类名.

java的类模板:

语法:

public calss<类名>{
	//定义属性部分
	属性1的类型  属性1;
	属性2的类型  属性2;
	......
	属性3的类型  属性3;
	
	//定义方法部分
	方法1;
	方法2;
	......
	方法n;
}

其中类的命名也要遵循一定的规则:

<1>.不能使用Java中的关键字

<2>不能包含任何嵌入的空格或点号".",以及下划线"_",字符"$"外的特殊符号

<3>不能以数字开头

规范:

》类名通常由多个单词组成，每个单词的首字母大写。

》另外，类名应该简洁而由意义，尽量使用完整单词，避免使用缩写词，除非该缩写词已被广泛使用，如HTML,HTTP,IP等.

如何定义类:

1.定义类名

通过定义类名得到程序最外层的框架

语法

public class 类名{
		//.......
}

2.编写类的属性

通过在类的主体中定义类变量来描述所具有的静态特征,(属性),这些变量称为类的成员变量.

3.编写类的方法

通过在类中定义方法来描述所具有的行为,这些方法称为类的成员方法

语法

访问修饰符  访问值类型 方法名(){
	//方法体
}

访问修饰符限制了访问该方法的范围,如public,还有其他的访问修饰符,这个类型可以是基本类型,或者是引用类型,也可以没有访问值,此时必须要用void来描述.方法名一般使用有意义的名字来描述该方法的作用,其命名规则与标识符的命名规则想符号.

示例2:

public class Yx2 {
	String schoolName;	//中心名称
	int classNumber; 	//教室数目
	int labNumber;		//机房数目
	
	//定义北大青鸟中心的方法
public void showCenter() {
		System.out.println(schoolName+"培训机构中心\n"+"配备:"+classNumber+"教"
	+labNumber+"机");
	}
}

如何创建和使用对象

定好了类,下面就可以根据类生成对象,称为类的实例化特征,一个实例也就是一个对象,一个类可以生成多个对象。创建对象的语法如下：

语法：

类名  对象名 =new 类名（）；

在创建类的对象名时,需要使用Java的new关键字.例如,创建School类的一个对象。
$S c h o o l c e n t e r = n e w S c h o o l ();$
center对象的类型是School 类型。使用new创建对象时，我们并没有给他们的数据成员赋一个特定的值。考虑到每个对象属性值可能是不一样的，所以在创建对象后再给它的数据成员赋值。

语法：

对象名.属性						//引用对象的属性
对象名.方法名						//引用对象的方法

示例 3：

public class Yx3 {
	public static void main(String[] args) {
		Yx2 center=new Yx2();
		System.out.println("***初始化成员变量前***");
		center.showCenter();
		center.schoolName="北京远航"; //给schoolName属性赋值
		center.classNumber=10;		//给classNumber属性赋值
		center.labNumber=10;		//给labNumber属性赋值
		System.out.println("\n***初始化成员变量后***");
		center.showCenter();
	}
}

声明：

main（）方法是程序的人口，可以出现在任何一个类中，但要保证一个Java类中只有一个main（）方法。因此，我们可以将main（）方法写在school类中。但这里，我们将main方法发在了initialSchool类中，目的是使不同的类实现不同的功能。

》使用关键字new创建的对象“center”

School center =new School();

》使用“."操作访问类的方法。

center.showCenter();

类型	默认值
int	0
double	0.0
char	“\u0000”
boolean	false
String	null

假如我们定义一个Scho’o’l类，可以用如下代码来实现方法与属性之间的内容：

第一步:

先定义一个学员类：

public class Visitor {
	String name;
	int age;
	public void show() {
		Scanner input =new Scanner (System.in);
		while (!"n".equals(name)) {
			if(age>=18&&age<=60) {
				System.out.println(name+"的年龄为:"+age+",门票价格为:20元\n");
			}else {
				System.out.println(name+"的年龄为:"+age+",门票免费\n");
			}
				System.out.println("请输入姓名");
				name=input.next();
				if(!"n".equals(name)) {
					System.out.println("请输入年龄:");
					age=input.nextInt();
				}
			}
			System.out.println("退出程序");
	}
}

第二步：

输出学员信息：

import java.util.Scanner;

public class InitialVistor {
	public static void main(String[] args) {
		Scanner input=new Scanner (System.in);
		Visitor v=new Visitor();
		System.out.println("请输入姓名");
		v.name =input.next();
		System.out.println("请输入年龄:");
		v.age=input.nextInt();
		v.show();
	}
}

下面我们也可以通过另外一个例子，来巩固类的使用。

问题：一个景区根据游人的年龄收取不同价格的门票，其中大于60岁或小于小于18岁的免费，18~60岁的20元。我们可以先编写一个（Visitor）类，根据年龄段决定能够购买的门票价格并输出。用户输入n则退出程序。

public class Visitor {
	String name;
	int age;
	public void show() {
		Scanner input =new Scanner (System.in);
		while (!"n".equals(name)) {
			if(age>=18&&age<=60) {
				System.out.println(name+"的年龄为:"+age+",门票价格为:20元\n");
			}else {
				System.out.println(name+"的年龄为:"+age+",门票免费\n");
			}
				System.out.println("请输入姓名");
				name=input.next();
				if(!"n".equals(name)) {
					System.out.println("请输入年龄:");
					age=input.nextInt();
				}
			}
			System.out.println("退出程序");
	}
}

后面我们就可以写它的测试类了：

输出门票信息：

import java.util.Scanner;

public class InitialVistor {
	public static void main(String[] args) {
		Scanner input=new Scanner (System.in);
		Visitor v=new Visitor();
		System.out.println("请输入姓名");
		v.name =input.next();
		System.out.println("请输入年龄:");
		v.age=input.nextInt();
		v.show();
	}
}

面向对象的优点：

》与人类的思维习惯一致：面向对象的思维方式从人类考虑问题的角度出发，把人类解决问题的思维过程转变为程序能够理解的过程，面向对象程序设计能够让我们使用”类“来模拟现实世界中的抽象概念。

》信息隐藏，提高了程序的可维性和安全性：封装了模块化和信息隐藏，即将类的属性和行为封装在类中，这保证了对它们的修改而不会影响其他对象，有利于维护。同时封装使得在对象外部不能随意访问对象的属性和方法，避免了外部错误对它的影响，提高了安全性。

》提高了程序的可重要性:一个类可以创建多个对象实例，增加了重用性。

十二章.类的无参方法

2.1类的方法和概述

什么是类的方法

类是由一组具有相同属性和共同行为的实体抽象而来的。对象执行的操作是通过编写类的方法实现的。显而易见，类的方法是一个功能模块，其作用是”做一件事情“。

下面就是一个创建分数类，它的属性和行为如示例1所示。

示例1

public class Sj1 {
	int java;
	int c;
	int db;
	public int showInf() {
		int avg=java+c+db;
		return avg;
	}
	public void showin() {
		System.out.println("总成绩是:"+showInf());
	}
	public double showav() {
		double avg1= (java+c+db)/3.0;
		return avg1;
	}
	public void showinfo2() {
		System.out.println("平均分是:"+showav());	
	}
}

那它的（Test)测试类为如下代码：

public class Sj1_{
	public static void main(String[] args) {
		Scanner input=new Scanner (System.in);
		Sj1 scc=new Sj1();
		System.out.println("请输入第一个数:");
		scc.java=input.nextInt  ();
		System.out.println("请输入第二个数:");
		scc.c=input.nextInt  ();
		System.out.println("请输入第三个数:");
		scc.db=input.nextInt  ();
		scc.showinfo2();
		scc.showin();
	}
}

如何定义类的方法

1.方法的名称

2.方法的返回值类型

3.方法的主体

语法

public 返回值类型方法名（）{
		//方法的主体
}

通常，编写方法时，分两步完成。

第一步：定义方法和返回值类型。

第二布：在{}中编写方法的主体部分

语法

return 表达式；

例如，在show（）方法中，返回值类型是String,因此在方法体中必须使用return返回一个字符串。

如果方法没有返回值，则返回值类型为void，例如加了void则返回值类型为void

其实在上面的代码中return语句是跳转语句的一种，它主要做两件事

》跳出方法。意思是”我已经完成了，要离开这个方法“

》给出结果。如果方法产生一个值，这个值发在return后面，即<表达式>部分，意思是离开这个方法，并将<表达式>的值返回给调用它的程序

语法
$对象名。方法名（）；$
java中类是程序的基本单元。每个对象需要完成特定的应用程序功能。

示例2

public class Kh2 {
	int shu1;
	int shu2;
	public int showjia() {
		int  score1=shu1+shu2;
		return score1;
		}
	public int showjian() {
		int  score2=shu1-shu2;
		return score2;
		}
	public int showch() {
		int  score3=shu1*shu2;
		return score3;
		}	 
	public int showchu() {
		int  score4=shu1/shu2;
		return score4;
		}
}

Test 测试类：

public class Kh2_ {
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		Kh2 name=new Kh2();
		System.out.println("请输入第一个数:");
		name.shu1=in.nextInt();
		System.out.println("请输入第二个数:");
		name.shu2=in.nextInt();
		System.out.println("请输入符号:");
		String fu=in.next();
		if(fu.equals("+")) {
			System.out.println(name.showjia());
		}else if(fu.equals("-")) {
			System.out.println(name.showjian());
		}else if(fu.equals("*")) {
			System.out.println(name.showch());
		}else if(fu.equals("/")) {
			System.out.println(name.showchu());
		}else {
			System.out.println("您输入有误");
		}
	}
}

2.2变量的作用域

成员变量和局部变量

成员变量：

在类中定义的变量我们称之为成员变量，如果其他类的方法要访问它，必须首先创建该类的对象，然后才能操作符”.“来引用

局部变量

在方法中定义的变量称为局部变量，它的作用域仅仅在该变量的方法中，因此只能在这个方法中能够使用

2.3javadoc注释

什么是javadoc注释

在前面章节中,我们已经学习了两种写注释的方法:单行注释(以"//“开头)和多行注释(以”/“开头,以”/"结尾):

//这是一个注释

*这是一个演程序

在java中还有一类注释,称为javaDoc注释.

例如:/**

*AccpSchool类

*@author JadeBird

*@version 1.0 2019/09/20

编写之前,首先看一下javaDoc注释的语法规则

1》javaDoc以·“/**”看头，以“*/”结尾

2》每个注释包含一些描述性的文本及若干个javaDoc标签

3》javaDoc标签一般yi“@”为前缀

标签	含义	标签
@author	作者名	@version	版本标识
@parameter	参数及意义	@since	最早使用该方法/类/接口的JDK版本
@return	返回值	@throws	异常类及抛出条件

如何生成javaDoc文档

添加玩javaDoc注释后，接下来就是生成相应的开发文档。生成JavaDoc开发文档的方法主要有两种

》使用命令行方式生成

》使用MyEclipse生成javaDoc的文档的操作很简单，选择”File"-——“Export"选项，弹出”导出“对话框，选择”java“菜单中的”javaDoc“选项，提交即可

十三章.带参数的方法

３.１定义带参方法

语法

<访问修饰符>返回值类型<方法名>(<参数列表>){
	//方法主体
}

其中:

》<访问修饰符>指该方法允许被访问的权限范围，只是public，，protected，private。其中public访问修饰符表示该方法可以被任何其他代码调用

》返回值类型指方法返回值的类型。如果方法不返回任何值，它应该声明为void类型，java对待返回值的要求和严格，方法返回值必须说明的类型相匹配，使用return语句返回值

》<方法名>是定义的方法的名字，它必须使用合法的标识符

》<参数列表>是传送给方法的参数列表。列表中各参数间以逗号分隔，参数列表的格式如下：

数据类型参数1，数据类型参数2·········，数据类型参数n,其中n>=0.

如果n=0，代表没有参数，这时的方法就是前面学过的无参方法

示例1：

public class StudentsBiz {
	String [] names=new String[30];	//学生姓名数组
	int i=0;
	public void addName(String name) {	//有参方法
		//增加学生姓名
		names[i]=name;
		i++;
	}
	public void showNames () {			//无参方法
		//显示全部学生姓名
		for (int i = 0; i < names.length; i++) {
			System.out.println(names[i]);
		}
	}
}

测试类

public class TestAdd {
	public static void main(String[] args) {
		StudentsBiz st=new StudentsBiz();
		Scanner input =new Scanner(System.in);
		for (int i = 0; i < 5; i++) {
			System.out.print("请输入学生姓名:");
			String newName=input.next();
			st.addName(newName);		//调用参数方法并传实参
		}
		st.showNames();					//显示全部学生的姓名
	}
}

带多个参数的方法（有多个返回值）

问题：在指定区间内查找学生姓名并显示是否成功

分析：在数组的某个区间查询学生姓名，设计方法通过传递三个参数（开始位置，结束位置，查找的姓名）来实现代码

示例２

public class Shili3{
	public boolean serachName(int start, int end,String name) {
		String[] names=new String[5];
		boolean find=false;		//是否找到标识
		//在指定的数组区间中找得到姓名
		for (int i = start-1; i <=3; i++) {
			if(names[i].equals(name)) {
				find=true;
				break;
			}
		}
		return find;
	}
}

测试类

public class ShIli3_ {
public static void main(String[] args) {
	Shili3 st=new Shili3();
	Scanner input=new Scanner(System.in);
	System.out.println("\n请输入开始查找的位置:");
	int s=input.nextInt();
	System.out.println("请输入结束查找的位置:");
	int e=input.nextInt();
	System.out.println("请输入查找的姓名:");
	String name=input.next();
	System.out.println("\n***查找结果****");
	if(st.serachName(s,e,name)) {
		System.out.println("找到啦!!");
	}else {
		System.out.println("没有找到该学生!");
	}
	}
}

对象数组

问题：假如有五位同学参加了ｊａｖａ知识的竞赛，输出决赛的平均成绩和最高成绩

示例３

public class StudentsBiz {
	/**
	 * 平均分
	 */
	public double calAvg(int[] scores) {
		int sum=0;
		double avg=0.0;
		for (int i = 0; i < scores.length; i++) {
			sum +=scores[i];
		}
		avg=(double)sum/scores.length;
		return avg;
	}
	/**
	 * 求最高分
	 * @param scores 参赛组数组
	 */
	public int calMax(int[]scores) {
		int max=scores[0];
		for (int i = 1; i < scores.length; i++) {
			if (max<scores[i]){
				max=scores[i];
			}
		}
		return max;
	}
}

测试类

public class TestCal {
	public static void main(String[] args) {
		StudentsBiz st=new StudentsBiz();
		int[] scores=new int[5];		//保存比赛成绩
		Scanner input=new Scanner (System.in);
		System.out.println("请输入五名参赛者的成绩:");
		for (int i = 0; i <5; i++) {		//循环接受成绩
			scores[i]=input.nextInt();
		}
		double avgScore=st.calAvg(scores);
		System.out.println("平均成绩:"+avgScore);
		//输出最高成绩
		int maxScore=st.calMax(scores);
		System.out.println("最高成绩:"+maxScore);
	}
}

３.３包的使用

为什么需要包

在生活中，保存文档时经常使用文件夹，把不同类型的文档归类，然后发到不同的文件中，易于查找和管理

包主要有以下三个方面的作用

（１）包允许将类组合成较小的单元格（类似文件夹），易于找到和使用相应的类文件

（２）防止命名冲突，Java中只有不同包中的类才能重名

（３）包允许在更广的范围内保护类，数据和方法，可以在包内定义类，根据规则，包外的代码有可能不能访问该类

如何声明包

要声明包(package),只要包含一个package命令作为一个Java源文件的第一条语句就可以,见示例:

package cn.jbit.classandobject;			//声明包
public class AccpSchool {
	//........
	public String toString () {
		//........
	}
}

在示例中,AccpSchool类就属于包cn.jbit.classandobject.

下面是声明包的通用形式

语法

package  包名;

package 是关键字.包的声明必须是java源文件中的第一条非注释性语句,而一个源文件只能有一个包声明语句.

1.Java包的名字通常都由小写字母组成,不能以圆点开头或结尾.

2.一个唯一包名的前缀通常是由全部小写的ASCLL字母,并且是一个顶级域名com,edu,gov,net,或org,通常使用组织的网络域名的逆序.

package cn.jbit.classandobject;

如何导入包

在使用import时可以指定类的完整描述,即"包名.类名",来导入包中的某个特定的类

语法

import 包名.类名;

这里的包名可以是系统提供的包,如Java.util.也可以是自己定义的包,如cn.jbit.classandobject;.如果使用到包下的某些类(多于一个),在使用import导入时,可以使用"包名*".语法如下:

语法

import 包名.*;

十四章,字符串

如何使用字符串

简单来说,使用字符串主要分为两步

(1)定义并初始化字符串

(2)使用字符串,对字符串进行一些处理

语法

//创建一个字符串对象"Hello Word"
String s="Hello Word";

字符串的长度

语法

字符串1.length();

示例1

public class Register {
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		String uname,pwd;
		System.out.println("请输入用户名:");
		uname=in.next();
		System.out.println("请输入密码：");
		pwd=in.next();
		if(pwd.length()>=6) {
			System.out.println("注册成功！");
		}else {
			System.out.println("密码长度不能小于6位！");
		}
	}
}

返回字符串1的长度.

字符串的比较

在使用equals()方法比较两个字符串时,它逐个对照组成两个字符串的每个字符是否相同.如果值都相同,则返回true;否则返回false.

语法

字符串1.equals(字符串2);

比较两个字符串的值是否相同,返回Boolean类型的值.如果相同,则返回true;否则返回false.

示例2

public class Login {
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		String uname,pwd;
		System.out.println("请输入用户名：");
		uname=in.next();
		System.out.println("请输入密码：");
		pwd=in.next();
		if(uname.equals("TOM")&&pwd.equals("1234567")) {
			System.out.println("登陆成功！");
		}else {
			System.out.println("用户名或密码不匹配，登录失败！");
		}
	}
}

在Java中双等号()和equals()方法虽然都应用于两个字符串,但判断的类容是有差别的.简单的讲"’'判断的是两个字符串对象所在类存中的地址是否相等,即判断是否是在同一个字符串对象,而equals()判断的是两个字符串是否相等.

示例3

public class Difference {
	public static void main(String[] args) {
		String st=new String("我爱我的祖国");
		String str=new String("我爱我的祖国");
		if(st.equals(str)) {
			System.out.println("两个字符串值相同。");
		}else {
			System.out.println("两个字符串值不相同。");
		}
		if(st==str) {
			System.out.println("两个字符串值相同。");
		}else {
			System.out.println("两个字符串值不相同。");
		}
	}
}

在使用equals()方法比较时,对于字符串的大小写,需要使用另一种方法—equalsgonorCase()方法.lgnore是"忽略"的意思,这种在比较字符串时会忽略字符的大小写.

语法

字符串1.equalsgonorCase(字符串2);

忽略大小写比较字符串1和字符串2.如果都相同,则返回值true,否则返回false

例如以下的演示代码:

public class Login1 {
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		System.out.println("请输入用户名：");
		String uname=in.next();
		System.out.println("请输入密码：");
		String pwd=in.next();
		if(uname.equalsIgnoreCase("TOM") && pwd.equalsIgnoreCase("1234567")) {
			System.out.println("登陆成功！");
		}else {
			System.out.println("用户名或密码不匹配，登陆失败！");
		}
	}
}

在Java中,String提供了两个方法改变字符串中字符的大小写

toLowerCase():转变字符串中的英文字母为小写

toUpperCase():转换字符串中的英文字母为大写

常用的提取和查询字符的方法

StringBuffer类

如何使用StringBuffer类

1.声明StringBuffer对象并初始化

//声明一个空的StringBuffer大小
StringBuffer bi=new StringBuffer ();
//声明一个字符串"青春无悔"
StringBuffer bi=new StringBuffer ("青春无悔");

2.使用StringBuffer对象

StringBuffer类提供了很多方法使用,调用时"."来操作

常用的StringBuffer类方法

语法

字符串1.toString();

将StringBuffer类型的字符串1转换为Stirng类型的对象并返回

例如:

String s1=sb.toString();				//转换为String类

语法

字符串1.append(字符串2);

该方法和String类型的concat()方法一样,都是把一个字符追加到另一个字符串后面,所不同的是String中只能将String类型的字符追加到一个字符串后,而StringBuffer可以将任何类型的值追加到字符串后.

示例

public class sbAppend {
	public static void main(String[] args) {
	StringBuffer sb=new StringBuffer("青春无悔");
	int num=110;
	//在字符串后面追加字符串
	StringBuffer sb1=sb.append("我心永恒");
	System.out.println(sb1);
	//在字符串后面追加字符
	StringBuffer sb2=sb1.append('啊');
	System.out.println(sb2);
	//在字符串后面追加整型数字
	StringBuffer sb3=sb2.append(num);
	System.out.println(sb3);
	}
}