类和对象的有参无参方法，字符串
类和对象
在前面的章节中，学习了程序设计的基本知识和流程控制语句。通过这些内容的学习，大家能够用Java语言进行程序设计，但这些程序的规模都很小，一般只有几十行代码。假设要编程解决一个很大的问题，需要写几万行代码，如果按照以前的做法，将这些代码都放在一个Java文件中，可以想象这个文件会冗长，而且很难维护。所以我们学习了Java程序设计的另一道风景——面向对象程序设计，英语缩写为oop。面向对象程序设计是一个里程碑，Alan Key因为设计了世界上第一个面向对象语言Smalltalk而获得图灵奖。Java之父James Gosling结合Internet背景设计了完全面向对象的Java语言。
对象
首先问大家一个问题世界有什么组成的？不同的人会有不同的回答，但如果你是一个分类学家，你会说：“这个世界是由不同类别的事物组成的”。其实，这个问题本身就比较抽象，物以类聚，所以可以说世界是由不同类别的事物构成的，所以世界由动物，植物，人和名胜等组成。动物可以分为脊椎动物和无脊椎动物。脊椎动物又可以分为哺乳类，鱼类，爬行类，鸟类和两栖类。爬行类又可以分为足类和无足类…就这样可以继续分下去。当提到某一个分类时，就可以找到属于该分类的一个具体事物。例如，乌龟就属于爬行类中的有足类，眼镜蛇就属于爬行类中的无足类。当我们提到这些具体动物时，会在脑海浮现出他们的形象。这些现实世界中客观存在的事物就称为对象。在Java的世界中“万物皆对象”。
身边的对象
现实世界中客观存在的任何事物都可以被看作对象。对象可以是有行的，如一辆汽车：它可以是无形的，如一项计划。因此对象无处不在。
Java是一种面向对象的编程语言，因此我们要协会用面相对象的思想考虑问题和编写程序。在面向对象中，对象是用来描述客观事物的一个实体。其实每一个对象都有自己的特征，包括静态特征和动态特征。静态特征是可以用某些数据来描述的特征，如人的姓名，年龄等。动态特征是对象所表现的行为或对象所具有的功能。把对象的静态特征和动态特征分别称为对象的属性和方法。其中属性是用来描述对象静态特征的一个数据项，该数据项的值即属性值。对象的属性被存储在一些变量里。
对象：用来描述客观事物的一个实体，由一组属性和方法构成。
类
类定义了对象将会拥有的特征(属性)和行为(方法)。
- 类的属性：对象会拥有的静态特征在类中表示时称为类的属性。
- 类的方法：对象执行的操作称为类的方法。
类和对象的关系
在Java面向对象编程中，就用这个类创建出类的一个实例，及创建类的一个对象。
一个类为他的全部对象给出了一个统一的定义，而它的每个对象则是符合这种定义的一个实体。因此类和对象的关系就是抽象和具体的关系。
类是对象的类型
到目前为止，我们已经学习了很多数据类型，如整型，双精度浮点型，字符型等。这些都是Java语言已经定义好的类型，编程时只需要用这些类型声明变量即可。
那么，如果想描述顾客“张浩”，他的数据类型是什么呢？是字符型还是字符串型？其实都不是。“张浩”的类型就是顾客，也就是说，类就是对象的类型。
Java是面向对象的语言
在面向对象程序设计中，雷士程序的基本单元，Java是完全面向对象的编程语言，所有程序都是以类为组织单元的。如下：
public class<类名>{
//定义属性部分
属性1的类型 属性1;
属性2的类型 属性2;
......
属性n的类型 属性n;
//定义方法部分
方法1;
方法2;
......
方法3;
}在Java中创建一个类，需要使用一个class，一个类名和一对大括号。其中，class是创建类的关键字。在class前有一个public，表示“共有”的意思。编写程序时。要注意编码规范，不要漏写public。在class关键字的后面要给定义的类命名，然后写上一对大括号，类的主体部分就写着{ }中。类似于给变量命名，类的命名也要遵循一定的规则：
- 不能使用Java中的关键字。
- 不能包含任何嵌入的空格或点号，以及下划线，字符“$”外的特殊字符。
- 不能以数字开头。
- 类名通常由多个单词组成，每个单词的首字母大写。
- 另外，类名应该简洁而又意义，尽量使用完整单词，避免使用缩写词，出发该缩写词已被广泛使用，如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 |
面向对象的优点
了解了类和对象，也学习了如何定义类，创建对象和使用方法，下面总结面向对象的优点，具体如下：
- 与人类的思维习惯一致：面向对象的思维方式从人类考虑问题的角度出发，把人类解决问题的思维过程转变为程序能够理解的过程。面向对象的程序设计能够让我们使用“类”来模拟现实世界中的抽象概念，用“对象”来模拟现实世界中的主体，从而用计算机解决现实问题。
- 信息隐藏，提高了程序的可维护性和安全性：封装实现了模块化和信息隐藏，即将类的属性和行为封装在类中，这保证了对他们的修改不会影响到其他对象，有利于维护。同时封装使得在对象外部不能随意访问对象的属性和方法，避免了外部错误对他的影响，提高了安全性。
- 提高了程序的可重用性：一个类可以创建多个对象示例，怎家了重用性。
面向对象程序设计还有其他的优点，在以后的学习中会慢慢结束。相信通过不断实践，学员的理解会不断加上。
本章总结
- 对象是用来描述客观事物的一个实体，由一组属性和方法构成
- 类定义了对象将会拥有的特征（属性）和行为（方法）。
- 类和对象的关系是抽象和具体的关系。类是对象的类型，对象是类的示例。
- 对象的属性和方法被共同封装在类中，相辅相成，不可分割
- 面向对象程序设计的优点如下。
- 与人类的思维习惯一致。
- 隐藏信息，提高了程序的可维护性和安全性。
- 提高了程序的可重用性。
使用类的步骤如下。
- 定义类：使用关键字class。
- 创建类的对象：使用关键字new
- 使用类的属性和方法：使用“.”操作符
类和对象的无参方法
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测试类
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);
}
}