类和对象的总结(2)
类和对象的总结(2)
类的组成部分:属性、方法。
其中,方法包括:1.普通方法
2.构造方法
一、构造方法
1.构造方法的格式:
public 类名(数据类型 参数名,…){
//代码
}
2.实例化对象的格式:
类名 对象=new 类名();//实例化不带参数的构造方法
类名 对象=new 类名(参数值,…);//实例化带参数的构造方法
3.用途: a.实例化对象
b.为对象赋初始值
N.B:Java会给每一个类提供一个默认的构造方法。但如果你在类中定义了构造方法,则只能使用你自己定义的构造方法。
二、方法重载
1.条件:a..方法名必须要相同
b.方法所带的参数类型、参数个数、参数顺序至少有一个不同。
2.调用:传入的参数和哪个方法定义时的参数相配,则调用对应的方法。
exp: //定义一个与怪物战斗的方法
public void fighting(Monster mon){
blood--;//血量减1
System.out.println(name+"被"+mon.getName()+"攻击了,血量仅剩"+blood+"滴");
}
//重载一个与Boss战斗的方法
public void fighting(Boss boss){
blood--;//血量减1
System.out.println(name+"被"+boss.getName()+"攻击了,血量仅剩"+blood+"滴");
}
}
三、this关键字
1.this表示当前调用方法的对象
2.this可以调用当前对象的属性值,exp:
public Student(String name){
this.name=name;
}
//这里的name值为”属性name”的值,这里是将name值赋给”this.name”,而这里的name值可以来自主函数的实例化对象,exp: Student stu=new Student(“becky”);
也可以调用另一个构造器.exp:
public Student(){
this(“未知名字”,”Java”,0);
}
//补充:当实例化对象无参数时,构造方法中的参数的值将不会成为实例化对象的初始值。//exp:Student stu=new Student();//此时无参数调入其中。//
public Student(String name,String km,int scro){
this.name=name;//这里的name=”未知名字”
this.km=km;//这里的km=”Java”
this.scro=scro;//这里的scro=0
}
N.B:在构造器中,可以调用构造器,也可以调用方法;但在一般方法中,不能调用构造器。
四、值传递
1.值传递:Java八大基本类型和String类型遵循“值传递”规则。
2.关于地址存储地:
1) exp: //主函数中
int i=100;
…….
stu.score(i);
//这里的i的地址存储在内存的栈中,在主函数结束后才会自行销毁,释放内存空间。//主函数中的i值不会受到类中s值变化的影响
2) exp: //类中
public void score(int s){
…..
s++;
…….
}//这里的s的地址存储在内存的栈中,用完后便会自动销毁,释放内存空间
五、引用传递
1.引用传递适用于Java的引用数据类型(对象类型、类类型)。
其中,引用数据类型包含:数组、类、接口、抽象类。
2.引用传递的方式:a.对象所带有的值存在堆里,对象的地址存在栈里,对象的地址指向对象值的首地址,从而把对象值找出来。
b.如果要将对象2的值赋给对象1,则应使对象1指向对象2的首地址,使“对象1=对象2”,最后在函数结束后,释放对象1在堆中的存储空间。
exp1: //入口函数中
Student st1 = new Student();...
st1=st2;
st2=st3;
st3=st1;
最后得到st3 = st2;
分析:
1.st1=st2 时,st1指向st2的首地址,st1的值变成st2的值。
2.st3=st1时,st3指向st1的首地址,st3 的值变成st1的值。
/*****************************************************************************/
课后练习:
回合制游戏:奥特曼和小怪兽要战斗,奥特曼还可以和Boss进行战斗,直到一方的血量为0的时候结束战斗,输出谁胜利了!
1.思路:先将游戏中的所有对象找全,再分别列出它们的特征和行为。然后为各个对象创建一个类。最后在主函数中模拟战斗场景,输出最终结果。
2.分析:
对象 特征 行为
奥特曼 姓名、血量 战斗
小怪兽 姓名、血量 战斗
Boss 姓名、血量 战斗
3.具体代码如下:
1)//定义一个超人类
public class Superman{
//定义一个姓名属性
private String name;
//定义一个血量属性
private int blood;
//定义一个带姓名参数的构造方法
public Superman(String name){
this.name="无名";
}
//重载一个不带参数的构造方法
public Superman(){
this.blood=10;
this.name="无名";
}
//设置姓名属性值的方法
public void setName(String n){
name=n;//将参数n的值赋给属性name
}
//获取姓名属性值的方法
public String getName(){
return name;
}
//设置血量属性值的方法
public void setBlood(int m){
blood=m;
}
//获取血量属性值的方法
public int getBlood(){
return blood;
}
//定义一个与怪物战斗的方法
public void fighting(Monster mon){
blood--;//血量减1
System.out.println(name+"被"+mon.getName()+"攻击了,血量仅剩"+blood+"滴");
}
//重载一个与Boss战斗的方法
public void fighting(Boss boss){
blood--;//血量减1
System.out.println(name+"被"+boss.getName()+"攻击了,血量仅剩"+blood+"滴");
}
}
2)//定义一个Monster类
public class Monster{
//定义一个姓名属性
private String name;
//定义一个血量属性
private int blood;
//定义一个带姓名参数的构造方法
public Monster(String name){
this.name="无名";
}
//重载一个带血量参数的构造方法
public Monster(int blood){
this.blood=10;
}
//设置姓名属性值的方法
public void setName(String n){
name=n;//将参数n的值赋给属性name
}
//获取姓名属性值的方法
public String getName(){
return name;
}
//设置血量属性值的方法
public void setBlood(int m){
blood=m;//将参数m的值赋给属性name
}
//获取血量属性值的方法
public int getBlood(){
return blood;
}
//定义一个与Superman战斗的方法
public void fighting(Superman sup){
blood--;//血量减1
System.out.println(name+"被"+sup.getName()+"攻击了,血量仅剩"+blood+"滴");
}
}
3)//定义一个Boss类
public class Boss{
//定义一个姓名属性
private String name;
//定义一个血量属性
private int blood;
//定义一个带姓名参数的构造方法
public Boss(String name){
this.name="无名";
}
//重载一个带血量参数的构造方法
public Boss(int blood){
this.blood=10;
}
//设置姓名属性值的方法
public void setName(String n){
name=n;//将参数n的值赋给姓名属性name
}
//获取姓名属性值的方法
public String getName(){
return name;
}
//设置血量属性值的方法
public void setBlood(int m){
blood=m;//将参数m的值赋给血量属性blood
}
//获取血量属性值的方法
public int getBlood(){
return blood;
}
//定义一个与Superman战斗的方法
public void fighting(Superman sup){
blood--;//血量减1
System.out.println(name+"被"+sup.getName()+"攻击了,血量仅剩"+blood+"滴");
}
}
4)//定义一个Fighting类
public class Fighting{
//定义程序的入口主函数
public static void main(String [] args){
//实例化一个Superman类的对象
Superman sup = new Superman();
//调用设置姓名的方法
sup.setName("奥特曼");
//调用设置血量的方法
sup.setBlood(20);
//实例化一个Monster类的对象
Monster mon = new Monster("zzz");
//调用设置姓名的方法
mon.setName("小怪兽");
//调用设置血量的方法
mon.setBlood(10);
//实例化一个Boss类的对象
Boss bo = new Boss("zzz");
//调用设置姓名的方法
bo.setName("boss");
//调用设置血量的方法
bo.setBlood(10);
//定义回合数
int i=20;
//开始进行20回合的较量,每回合奥特曼有2次攻击机会,小怪兽和boss各有一次攻击机会
while(i>0){
//调用战斗方法
sup.fighting(mon);
//调用战斗方法
sup.fighting(bo);
//调用战斗方法
mon.fighting(sup);
//调用战斗方法
bo.fighting(sup);
i--;
//将奥特曼目前的血量值赋给sblood
int sblood =sup.getBlood();
//将小怪兽目前的血量值赋给mblood
int mblood=mon.getBlood();
//将boss目前的血量值赋给bblood
int bblood=bo.getBlood();
//如果奥特曼的血量先为0,输出最终结果
if(sblood==0){
System.out.println("奥特曼战败!小怪兽和boss战胜!");
break;//跳出循环
}
//如果小怪兽的血量先为0,输出最终结果
else if(mblood==0){
System.out.println("奥特曼战胜!小怪兽和boss战败!");
break;//跳出循环
}
//如果boss的血量先为0,输出最终结果
else if(bblood==0){
System.out.println("奥特曼战胜!小怪兽和boss战败!");
break;//跳出循环
}
}
}
}
4.编码过程中应注意的一些问题:
a.在这个游戏中,构造方法可用可不用。
b.若是选择使用构造方法,则要注意:自己在主函数中实例化的对象的构造方法是否带有参数,如果带参数,那么在实例化这个构造方法的时候我们也要带上参数,
exp: 在对象的类中有: public Boss(String name){
this.name="无名";
}
则在主函数中实例化为:Monster mon = new Monster("zzz");
反之,如果不带参数,那么在实例化这个构造方法的时候我们也不必带上参数。
exp: 在对象的类中有: public Superman(){
this.blood=10;
this.name="无名";
}
则在主函数中实例化为:Superman sup = new Superman();
c.在一方血量为0时,输出结果后记得要加上“break”,跳出循环;否则战斗将继续进行。
类的组成部分:属性、方法。
其中,方法包括:1.普通方法
2.构造方法
一、构造方法
1.构造方法的格式:
public 类名(数据类型 参数名,…){
//代码
}
2.实例化对象的格式:
类名 对象=new 类名();//实例化不带参数的构造方法
类名 对象=new 类名(参数值,…);//实例化带参数的构造方法
3.用途: a.实例化对象
b.为对象赋初始值
N.B:Java会给每一个类提供一个默认的构造方法。但如果你在类中定义了构造方法,则只能使用你自己定义的构造方法。
二、方法重载
1.条件:a..方法名必须要相同
b.方法所带的参数类型、参数个数、参数顺序至少有一个不同。
2.调用:传入的参数和哪个方法定义时的参数相配,则调用对应的方法。
exp: //定义一个与怪物战斗的方法
public void fighting(Monster mon){
blood--;//血量减1
System.out.println(name+"被"+mon.getName()+"攻击了,血量仅剩"+blood+"滴");
}
//重载一个与Boss战斗的方法
public void fighting(Boss boss){
blood--;//血量减1
System.out.println(name+"被"+boss.getName()+"攻击了,血量仅剩"+blood+"滴");
}
}
三、this关键字
1.this表示当前调用方法的对象
2.this可以调用当前对象的属性值,exp:
public Student(String name){
this.name=name;
}
//这里的name值为”属性name”的值,这里是将name值赋给”this.name”,而这里的name值可以来自主函数的实例化对象,exp: Student stu=new Student(“becky”);
也可以调用另一个构造器.exp:
public Student(){
this(“未知名字”,”Java”,0);
}
//补充:当实例化对象无参数时,构造方法中的参数的值将不会成为实例化对象的初始值。//exp:Student stu=new Student();//此时无参数调入其中。//
public Student(String name,String km,int scro){
this.name=name;//这里的name=”未知名字”
this.km=km;//这里的km=”Java”
this.scro=scro;//这里的scro=0
}
N.B:在构造器中,可以调用构造器,也可以调用方法;但在一般方法中,不能调用构造器。
四、值传递
1.值传递:Java八大基本类型和String类型遵循“值传递”规则。
2.关于地址存储地:
1) exp: //主函数中
int i=100;
…….
stu.score(i);
//这里的i的地址存储在内存的栈中,在主函数结束后才会自行销毁,释放内存空间。//主函数中的i值不会受到类中s值变化的影响
2) exp: //类中
public void score(int s){
…..
s++;
…….
}//这里的s的地址存储在内存的栈中,用完后便会自动销毁,释放内存空间
五、引用传递
1.引用传递适用于Java的引用数据类型(对象类型、类类型)。
其中,引用数据类型包含:数组、类、接口、抽象类。
2.引用传递的方式:a.对象所带有的值存在堆里,对象的地址存在栈里,对象的地址指向对象值的首地址,从而把对象值找出来。
b.如果要将对象2的值赋给对象1,则应使对象1指向对象2的首地址,使“对象1=对象2”,最后在函数结束后,释放对象1在堆中的存储空间。
exp1: //入口函数中
Student st1 = new Student();...
st1=st2;
st2=st3;
st3=st1;
最后得到st3 = st2;
分析:
1.st1=st2 时,st1指向st2的首地址,st1的值变成st2的值。
2.st3=st1时,st3指向st1的首地址,st3 的值变成st1的值。
/*****************************************************************************/
课后练习:
回合制游戏:奥特曼和小怪兽要战斗,奥特曼还可以和Boss进行战斗,直到一方的血量为0的时候结束战斗,输出谁胜利了!
1.思路:先将游戏中的所有对象找全,再分别列出它们的特征和行为。然后为各个对象创建一个类。最后在主函数中模拟战斗场景,输出最终结果。
2.分析:
对象 特征 行为
奥特曼 姓名、血量 战斗
小怪兽 姓名、血量 战斗
Boss 姓名、血量 战斗
3.具体代码如下:
1)//定义一个超人类
public class Superman{
//定义一个姓名属性
private String name;
//定义一个血量属性
private int blood;
//定义一个带姓名参数的构造方法
public Superman(String name){
this.name="无名";
}
//重载一个不带参数的构造方法
public Superman(){
this.blood=10;
this.name="无名";
}
//设置姓名属性值的方法
public void setName(String n){
name=n;//将参数n的值赋给属性name
}
//获取姓名属性值的方法
public String getName(){
return name;
}
//设置血量属性值的方法
public void setBlood(int m){
blood=m;
}
//获取血量属性值的方法
public int getBlood(){
return blood;
}
//定义一个与怪物战斗的方法
public void fighting(Monster mon){
blood--;//血量减1
System.out.println(name+"被"+mon.getName()+"攻击了,血量仅剩"+blood+"滴");
}
//重载一个与Boss战斗的方法
public void fighting(Boss boss){
blood--;//血量减1
System.out.println(name+"被"+boss.getName()+"攻击了,血量仅剩"+blood+"滴");
}
}
2)//定义一个Monster类
public class Monster{
//定义一个姓名属性
private String name;
//定义一个血量属性
private int blood;
//定义一个带姓名参数的构造方法
public Monster(String name){
this.name="无名";
}
//重载一个带血量参数的构造方法
public Monster(int blood){
this.blood=10;
}
//设置姓名属性值的方法
public void setName(String n){
name=n;//将参数n的值赋给属性name
}
//获取姓名属性值的方法
public String getName(){
return name;
}
//设置血量属性值的方法
public void setBlood(int m){
blood=m;//将参数m的值赋给属性name
}
//获取血量属性值的方法
public int getBlood(){
return blood;
}
//定义一个与Superman战斗的方法
public void fighting(Superman sup){
blood--;//血量减1
System.out.println(name+"被"+sup.getName()+"攻击了,血量仅剩"+blood+"滴");
}
}
3)//定义一个Boss类
public class Boss{
//定义一个姓名属性
private String name;
//定义一个血量属性
private int blood;
//定义一个带姓名参数的构造方法
public Boss(String name){
this.name="无名";
}
//重载一个带血量参数的构造方法
public Boss(int blood){
this.blood=10;
}
//设置姓名属性值的方法
public void setName(String n){
name=n;//将参数n的值赋给姓名属性name
}
//获取姓名属性值的方法
public String getName(){
return name;
}
//设置血量属性值的方法
public void setBlood(int m){
blood=m;//将参数m的值赋给血量属性blood
}
//获取血量属性值的方法
public int getBlood(){
return blood;
}
//定义一个与Superman战斗的方法
public void fighting(Superman sup){
blood--;//血量减1
System.out.println(name+"被"+sup.getName()+"攻击了,血量仅剩"+blood+"滴");
}
}
4)//定义一个Fighting类
public class Fighting{
//定义程序的入口主函数
public static void main(String [] args){
//实例化一个Superman类的对象
Superman sup = new Superman();
//调用设置姓名的方法
sup.setName("奥特曼");
//调用设置血量的方法
sup.setBlood(20);
//实例化一个Monster类的对象
Monster mon = new Monster("zzz");
//调用设置姓名的方法
mon.setName("小怪兽");
//调用设置血量的方法
mon.setBlood(10);
//实例化一个Boss类的对象
Boss bo = new Boss("zzz");
//调用设置姓名的方法
bo.setName("boss");
//调用设置血量的方法
bo.setBlood(10);
//定义回合数
int i=20;
//开始进行20回合的较量,每回合奥特曼有2次攻击机会,小怪兽和boss各有一次攻击机会
while(i>0){
//调用战斗方法
sup.fighting(mon);
//调用战斗方法
sup.fighting(bo);
//调用战斗方法
mon.fighting(sup);
//调用战斗方法
bo.fighting(sup);
i--;
//将奥特曼目前的血量值赋给sblood
int sblood =sup.getBlood();
//将小怪兽目前的血量值赋给mblood
int mblood=mon.getBlood();
//将boss目前的血量值赋给bblood
int bblood=bo.getBlood();
//如果奥特曼的血量先为0,输出最终结果
if(sblood==0){
System.out.println("奥特曼战败!小怪兽和boss战胜!");
break;//跳出循环
}
//如果小怪兽的血量先为0,输出最终结果
else if(mblood==0){
System.out.println("奥特曼战胜!小怪兽和boss战败!");
break;//跳出循环
}
//如果boss的血量先为0,输出最终结果
else if(bblood==0){
System.out.println("奥特曼战胜!小怪兽和boss战败!");
break;//跳出循环
}
}
}
}
4.编码过程中应注意的一些问题:
a.在这个游戏中,构造方法可用可不用。
b.若是选择使用构造方法,则要注意:自己在主函数中实例化的对象的构造方法是否带有参数,如果带参数,那么在实例化这个构造方法的时候我们也要带上参数,
exp: 在对象的类中有: public Boss(String name){
this.name="无名";
}
则在主函数中实例化为:Monster mon = new Monster("zzz");
反之,如果不带参数,那么在实例化这个构造方法的时候我们也不必带上参数。
exp: 在对象的类中有: public Superman(){
this.blood=10;
this.name="无名";
}
则在主函数中实例化为:Superman sup = new Superman();
c.在一方血量为0时,输出结果后记得要加上“break”,跳出循环;否则战斗将继续进行。
相关推荐
Java中的类和对象总结Java中的类和对象总结
php5 类与对象 个人总结与简单的例子,类与对象1. PHP 类与对象 2. PHP 类的继承 extends 关键字 3. PHP 构造方法 __construct() 4. PHP 析构方法 __destruct() 5. PHP final 关键字 6. PHP 类的接口 interface...
2.以下是一个类中包含另一个类对象成员(类的组合)的例子,试分析并给出程序的运行结果. #include class Son { int age; public: Son(){ age=1;} Son(int i){age=i;} void print(){ cout儿子的年龄是:";} ...
NULL 博文链接:https://season-jy.iteye.com/blog/2202154
第10章类和对象[总结].pdf
NULL 博文链接:https://swac.iteye.com/blog/1972827
Java第4章 认识类和对象.含源代码
总结_类和对象(答案).xmind
使用类的对象还是指针,总结了下,给有疑问的朋友做个参考
类(class):就是对象的类型,代表了某一批对象的共同特性和特征。类是对象的抽象,而对象是类的具体实例。 2.1 类的引入 在C语言中我们定义一个结构体是这样定义的: struct Student { int _age; char* _...
C++类和对象1
1、编写一个名为“复数”的类,包含复数的实部和虚部(数据成员),以及复数之间的基本算术运算:加、减(方法成员),并要求复数加减运算,程序运行中能对给定的复数进行运算,并打印运算的结果。 2、用类来描述游戏...
Java面向对象总结,总结了什么是面向对象,详细总结 类和对象、封装、继承、多态、抽象类、接口 的概念及使用
类和对象的关系 对象是对客观事物的抽象,类是对对象的抽象。类是一种抽象的数据类型。 定义为 class 类名{ } 它们的关系是,对象是类的实例,类是对象的模板。
一、实验目的 1.通过对所选题目相关需求的分析,掌握需求分析的方法和过程; 2.掌握需求分析相关文档的组织规范; 3. 完成一个小型软件系统的需求分析。
我初步总结一下关于python类和对象常用的它们的一些语法。
2015.6.13--java第六章类和对象章总结[借鉴].pdf
2.理解并掌握Java中定义类、创建对象、使用对象成员的方法 3.掌握Java类中方法的传值 4.掌握对象的组合 实验要求: 1.按照要求编制程序; 3.为增加程序可读性,请在程序中对类成员进行适当注释说明; 4.整理...
该变量在内存中只会保存一份,被类和所有对象共享, 那么一个对象对其进行修改,会影响到其他对象,为了不影响其他对象,经常会把静态变量搞成常量,被final修饰;