类和对象的有参无参方法，字符串

类和对象

在前面的章节中，学习了程序设计的基本知识和流程控制语句。通过这些内容的学习，大家能够用Java语言进行程序设计，但这些程序的规模都很小，一般只有几十行代码。假设要编程解决一个很大的问题，需要写几万行代码，如果按照以前的做法，将这些代码都放在一个Java文件中，可以想象这个文件会冗长，而且很难维护。所以我们学习了Java程序设计的另一道风景——面向对象程序设计，英语缩写为oop。面向对象程序设计是一个里程碑，Alan Key因为设计了世界上第一个面向对象语言Smalltalk而获得图灵奖。Java之父James Gosling结合Internet背景设计了完全面向对象的Java语言。

对象

首先问大家一个问题世界有什么组成的？不同的人会有不同的回答，但如果你是一个分类学家，你会说：“这个世界是由不同类别的事物组成的”。其实，这个问题本身就比较抽象，物以类聚，所以可以说世界是由不同类别的事物构成的，所以世界由动物，植物，人和名胜等组成。动物可以分为脊椎动物和无脊椎动物。脊椎动物又可以分为哺乳类，鱼类，爬行类，鸟类和两栖类。爬行类又可以分为足类和无足类…就这样可以继续分下去。当提到某一个分类时，就可以找到属于该分类的一个具体事物。例如，乌龟就属于爬行类中的有足类，眼镜蛇就属于爬行类中的无足类。当我们提到这些具体动物时，会在脑海浮现出他们的形象。这些现实世界中客观存在的事物就称为对象。在Java的世界中“万物皆对象”。

身边的对象

现实世界中客观存在的任何事物都可以被看作对象。对象可以是有行的，如一辆汽车：它可以是无形的，如一项计划。因此对象无处不在。

Java是一种面向对象的编程语言，因此我们要协会用面相对象的思想考虑问题和编写程序。在面向对象中，对象是用来描述客观事物的一个实体。其实每一个对象都有自己的特征，包括静态特征和动态特征。静态特征是可以用某些数据来描述的特征，如人的姓名，年龄等。动态特征是对象所表现的行为或对象所具有的功能。把对象的静态特征和动态特征分别称为对象的属性和方法。其中属性是用来描述对象静态特征的一个数据项，该数据项的值即属性值。对象的属性被存储在一些变量里。

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

类

类定义了对象将会拥有的特征(属性)和行为(方法)。

• 类的属性：对象会拥有的静态特征在类中表示时称为类的属性。
• 类的方法：对象执行的操作称为类的方法。

类和对象的关系

在Java面向对象编程中，就用这个类创建出类的一个实例，及创建类的一个对象。

一个类为他的全部对象给出了一个统一的定义，而它的每个对象则是符合这种定义的一个实体。因此类和对象的关系就是抽象和具体的关系。

类是对象的类型

到目前为止，我们已经学习了很多数据类型，如整型，双精度浮点型，字符型等。这些都是Java语言已经定义好的类型，编程时只需要用这些类型声明变量即可。

那么，如果想描述顾客“张浩”，他的数据类型是什么呢？是字符型还是字符串型？其实都不是。“张浩”的类型就是顾客，也就是说，类就是对象的类型。

Java是面向对象的语言

在面向对象程序设计中，雷士程序的基本单元，Java是完全面向对象的编程语言，所有程序都是以类为组织单元的。如下：

扫描二维码关注公众号，回复： 10090496 查看本文章

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

在Java中创建一个类，需要使用一个class，一个类名和一对大括号。其中，class是创建类的关键字。在class前有一个public，表示“共有”的意思。编写程序时。要注意编码规范，不要漏写public。在class关键字的后面要给定义的类命名，然后写上一对大括号，类的主体部分就写着{ }中。类似于给变量命名，类的命名也要遵循一定的规则：

1. 不能使用Java中的关键字。
2. 不能包含任何嵌入的空格或点号，以及下划线，字符“$”外的特殊字符。
3. 不能以数字开头。

• 类名通常由多个单词组成，每个单词的首字母大写。
• 另外，类名应该简洁而又意义，尽量使用完整单词，避免使用缩写词，出发该缩写词已被广泛使用，如HTML，HTTP,IP等

如何定义类

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

编写类的属性：通过在类的主题中定义变量来描述类所具有的静态特征（属性），这些变量称为类的成员变量

编写类的方法：通过在类中定义方法来描述所具有的·行为，这些方法称为类的成员方法。知道了定义一个类的步骤下面看我咋编写的：

public class Person{
    String name; //字符串是引用类型，不是基本数据类型变量
    int age;
    int weight;
     
	public void eat() {
		System.out.println("人可以吃饭!");
	}
	public void sleep() {
		System.out.println("人可以睡觉！");
	}
	public void play() {
		System.out.println("人可以玩游戏！");
		
	}
}

访问修饰符限制了访问该方法，如public，还有其他的访问修饰符，等下在讲返回值类型是方法执行后返回结果的类型，这个类型，这个类型是基本类型，或者是应用类型，也可以没有返回，此时必须使用void来描述。方法名一般使用一个有意义的名字来描述该方法的作用。其命名应该符合标识符的命名规则。

如何创建和使用对象

类的作用就是创建对象。由类生成对象，称为类的实例化过程。一个示例也就是一个对象，一个类可以生成多个对象。创建对象语法如下：

类名 对象名 = new 类名();

在创建类的对象时，需要使用Java的new关键字。

考虑到每个对象的属性值可能是不一样的，所以在创建对象后再给它的数据成员赋值。在Java中，要引用对象的属性和方法，需要使用“ . ”操作符。其中，对象名在圆点的左边，属性或方法的名称在圆点的右边。如下：

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

Java数据类型的默认值：

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

面向对象的优点

了解了类和对象，也学习了如何定义类，创建对象和使用方法，下面总结面向对象的优点，具体如下：

• 与人类的思维习惯一致：面向对象的思维方式从人类考虑问题的角度出发，把人类解决问题的思维过程转变为程序能够理解的过程。面向对象的程序设计能够让我们使用“类”来模拟现实世界中的抽象概念，用“对象”来模拟现实世界中的主体，从而用计算机解决现实问题。
• 信息隐藏，提高了程序的可维护性和安全性：封装实现了模块化和信息隐藏，即将类的属性和行为封装在类中，这保证了对他们的修改不会影响到其他对象，有利于维护。同时封装使得在对象外部不能随意访问对象的属性和方法，避免了外部错误对他的影响，提高了安全性。
• 提高了程序的可重用性：一个类可以创建多个对象示例，怎家了重用性。

面向对象程序设计还有其他的优点，在以后的学习中会慢慢结束。相信通过不断实践，学员的理解会不断加上。

本章总结

• 对象是用来描述客观事物的一个实体，由一组属性和方法构成
• 类定义了对象将会拥有的特征（属性）和行为（方法）。
• 类和对象的关系是抽象和具体的关系。类是对象的类型，对象是类的示例。
• 对象的属性和方法被共同封装在类中，相辅相成，不可分割
• 面向对象程序设计的优点如下。

1. 与人类的思维习惯一致。
2. 隐藏信息，提高了程序的可维护性和安全性。
3. 提高了程序的可重用性。

使用类的步骤如下。

1. 定义类：使用关键字class。
2. 创建类的对象：使用关键字new
3. 使用类的属性和方法：使用“.”操作符

类和对象的无参方法

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变量的作用域

成员变量和局部变量

成员变量：

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

局部变量

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

javadoc注释

么是javadoc注释

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

//这是一个注释

/*

*这是一个演程序

*/

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

例如:/**

*AccpSchool类

*@author JadeBird

*@version 1.0 2019/09/20

*/

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

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

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

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

如何生成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);
	}
}