面向对象之远哥法师和战士组队游戏管理操作系统

最新推荐文章于 2022-07-27 21:19:36 发布
最新推荐文章于 2022-07-27 21:19:36 发布
阅读量201 收藏
点赞数
分类专栏： 面向对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45442261/article/details/108831714
版权

/**

  • 笔记0927
    *对象数组起始位置可以初始化几个元素
    // 1.功能五 判断队名是否重复2.给队起名；3.队伍建队用flag循环判断是否队伍已满；
  • 2.功能六 遍历二维数组子元素的方法

*3.Role[] roles = new Role[0];// 建立角色对象数组【只有初始值为0或者初始化元素个数等于数组查高度时采用数组扩容和截取数组；否则用getMax方法获得最大实际长度，增加最后一位赋值给arr[getMax()],删除时顺次移位即可，末位清空，index+1开始

Team teams[] = new Team[0];// 建立队伍对象数组
// 初始化几个角色

public Manager() {//初始化时，可以初始化整个数组若干个元素；
	roles = new Role[] { new Magicer("s1", 1), new Magicer("s2", 2), new Magicer("s3", 3), new Magicer("s4", 4),
			new Soldier("s5", 50), new Soldier("s6", 60), new Soldier("s7", 70) };
}

4.多态的具体运用
4-1在遍历时，可以父类中用this判断包含关系，进行强转父类this，然后输出，【子类也可以重写父类的方法toString，构成多态输出；】
4-2添加时，类型自动转换，
4-3，修改时判断父类包含子类后，建立子类对象，可以给子类的其他属性进行赋值
4-4查找是否包含子类时，先判断输入种类进行非空判断，然后判断
if (animals[i] instanceof Monkey && role.equals(“猴子”)) {

			System.out.println(animals[i].showInfo());
			flag= true;

5.用抽象类写父类代码质量会更高些，父类如果用抽象，那么不允许建立对象，实例化对象没有意义；
6.修改子类特有属性，当修改子类属性时，首先instanceof判断属于关系，然后建立对象强转Magicer m=(Magicer)roles[index]; m.setLevel(input.nextInt（）)最后把修改后的属性重新赋值给数组中元素；roles【index】=m;
7.新名词学习，单一性【在继承关系中，子类只能有一个父类】
8.光标变为十字架取消：alt+shift+a

  • */
package cn.kgc.tyl.test0925.game.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
/**
*@author tyl
*@date 2020年9月27日
 @version 1.0
* */
/**
*
父类（角色类）
* */
@Setter
@Getter


public  class Role {
   public Role() {
   	super();
   	
   }
   public Role(String name) {
   	super();
   	this.name = name;
   }
   private String name;
   public  int attack() {return 0;};
    public String showInfo() {
   	
   	 return null;
    }
//	@Override
//	public String toString() {//注意是this，不是this.//不可以用Role,Role是类，用this代替当前类的对象；
//		String msg="";
//		if (this instanceof Magicer) {//在多态条件下存在继承关系，可以在父类中通过强制转换，输出子类信息；
//			Magicer m=(Magicer)this;
//			msg="魔法师，姓名"+m.getName()+",魔法等级"+m.getLevel()+",攻击值"+m.attack();
//		}else  if (this instanceof Soldier){
//			Soldier s=(Soldier)this;
//			msg="战士，姓名"+s.getName()+",体魄"+s.getMul()+",攻击值"+s.attack();
//		}
//		return msg;
//	}
//	 单一职责原则，父类创建对象没有意义，在子类中写输出语句；showinfo或者重写toString
}
**********************************************************************
package cn.kgc.tyl.test0925.game.entity;

import lombok.ToString;

/**
*
* 子类（魔法师类）
*/
@ToString
public class Magicer extends Role {
   private int level;// 魔法等级（范围为 1 ~ 10）

   public int getLevel() {
   	return level;
   }

   public void setLevel(int level) {
   	if (level > 10 || level < 0) {
   		this.level = 1;
   	} else {
   		this.level = level;
   	}

   }

   @Override
   public int attack() {

   	return getLevel() * 5;
   }

   public Magicer() {
   	super();

   }

   public Magicer(String name, int level) {
   	super(name);
   	this.level = level;
   }

   public String showInfo() {
   	return "魔法师，姓名" + getName() + ",魔法等级" + getLevel() + ",攻击值" + attack();
   }

}
*************************************************************************************************************************
package cn.kgc.tyl.test0925.game.entity;

import lombok.NoArgsConstructor;
import lombok.ToString;

/**
*
子类（战士类）
* */
@ToString
@NoArgsConstructor
public class Soldier extends Role {
private int mul;//体魄

   public int getMul() {
   return mul;
}

public void setMul(int mul) {
   if (mul>100||mul<0) {
   	this.mul =10;
   }else {
   	this.mul = mul;
   }
   
}

   public Soldier(String name,int mul) {
   super(name);
   this.mul = mul;
}

   @Override//该方法返回战士的攻击对敌人造成的伤害值
   public int attack() {
   	
   	return getMul()*10;
   }
   public String showInfo() {
   	return "战士，姓名" + getName() + ",体魄" + getMul() + ",攻击值" + attack();
   }

}
***************************************************************************************************8
package cn.kgc.tyl.test0925.game.entity;

import java.util.Arrays;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
*
* 队伍类【每队最多五人；】
*/
@Data
@NoArgsConstructor
@AllArgsConstructor

public class Team {
   private String tName;// 队名

   private Role[] ms;// 队伍数组含队员

}
******************************************************************************
package cn.kgc.tyl.test0925.game.manager;

import java.util.Arrays;
/**
*1.注意下标越界问题，删除时从index+1开始，因为index=i-1>=0;所以 i=index+1开始
 2.审题一定要仔细，比如更改时，题目要求名字修改成功后是否修改等级，体魄；小功能未完全实现；
 3.一旦进行封装，用setget方法防止非法传参，在有参构造方法中一定要调用set方法；
* */
import java.util.Scanner;

import cn.kgc.tyl.test0925.game.entity.Magicer;
import cn.kgc.tyl.test0925.game.entity.Role;
import cn.kgc.tyl.test0925.game.entity.Soldier;
import cn.kgc.tyl.test0925.game.entity.Team;

public class Manager {
   Role[] r = new Role[100];
   Team[] ts = new Team[0];// 建立队伍对象数组；

   /**
    *
    * 初始化方法
    */
   public void initial() {
   	r[0] = new Magicer("玛丽", 5);
   	r[1] = new Soldier("老唐", 2);
   	r[2] = new Soldier("李阳", 3);
   }

   /**
    *
    * 菜单的操作方法
    */

   int choice = 0;// 选项
   int result = 0;// 方法返回的结果；

   public void menu() {

   	Scanner input = new Scanner(System.in);

   	System.out.println("欢迎使用远哥法师和战士组队游戏管理操作系统\n1.添加角色\n2.查询角色\n3.删除角色\n4.修改角色\n5.组队\n6.查询队伍\n0.退出\n请选择>>");
   	choice = input.nextInt();
   	switch (choice) {
   	case 1:
   		add();
   		break;
   	case 2:
   		query();
   		break;
   	case 3:
   		del();
   		break;
   	case 4:
   		modify();
   		break;
   	case 5:
   		addTeam();
   		break;
   	case 6:
   		queryTeam();
   		break;
   	case 0:
   		System.out.println("输入0确认退出，按其他键继续进行");
   		String ans = "";
   		exit(ans);
   		break;

   	default:
   		System.out.println("请选择正确功能编号>>>");
   		break;

   	}
   	menu();

   }

   /**
    *
    * 获取最大长度；
    */

   public int getMax() {
   	int max = 0;
   	for (int i = 0; i < r.length; i++) {
   		if (r[i] == null) {
   			max = i;
   			break;
   		}
   	}
   	return max;
   }

   /**
    *
    * 获取下标；
    */

   public int getIndex(String name) {
   	int index = -1;
   	for (int i = 0; i < r.length; i++) {
   		if (r[i] != null&&name.equals(r[i].getName())) {
   			index = i;
   			break;//找到就停止
   		}
   	}
   	return index;
   }

   /**
    *
    * 名字是否重名
    */
   public boolean isNameExists(String name) {
   	boolean flag = true;// 假设名字不存在；
   	for (int i = 0; i < r.length; i++) {
   		if (r[i] != null && r[i].getName().equals(name)) {
   			flag = false;// 名字已存在；
   		}
   	}
   	return flag;
   }

   /**
    * 添加方法
    */
   public void add() {
   	System.out.println("选择类型1.魔法师2战士");
   	Scanner input = new Scanner(System.in);
   	int choice = input.nextInt();
   	if (choice == 1) {
   		Magicer m = new Magicer();
   		System.out.println("角色名");
   		String name = input.next();
   		boolean flag = isNameExists(name);
   		if (!flag) {
   			System.out.println("该角色已存在，添加失败");
   		} else {
   			m.setName(name);
   			System.out.println("魔法等级");
   			m.setLevel(input.nextInt());
   			r[getMax()] = m;
   			System.out.println("添加成功");
   			query();
   		}
   	} else if (choice == 2) {
   		Soldier s = new Soldier();
   		System.out.println("角色名");
   		String name = input.next();
   		boolean flag = isNameExists(name);
   		if (!flag) {
   			System.out.println("该角色已存在，添加失败");
   		} else {
   			s.setName(name);
   			System.out.println("体魄");
   			s.setMul(input.nextInt());
   			r[getMax()] = s;
   			System.out.println("添加成功");
   			query();
   		}
   	} else {
   		System.out.println("没有您输入添加角色的类型，添加失败");
   	}

   }

   /**
    * 查询方法
    */
   public void query() {

   	System.out.println("当前队员信息有，");
   	for (int i = 0; i < r.length; i++) {
   		if (r[i] != null) {
   			System.out.println((i + 1) + "," + r[i].showInfo());
   		

   		}
   	}

   }

   /**
    * 删除方法
    */
   public void del() {
   	int index = -1;// 不能初始化为0，数组中本身存在，否则每次删除都是把第一位元素删除
   	System.out.println("删除的名字");
   	Scanner input = new Scanner(System.in);

   	String name = input.next();
   	boolean flag = isNameExists(name);
   	if (flag) {
   		System.out.println("名字不存在，删除失败");
   	} else {
   		index = getIndex(name);
   	    r[index] = null;
    
//	for (int i = index; i < getMax()-1; i++) {//删除从0开始时就会失败，下标越界；开始从index+1；
//		r[i]=r[i+1];
//	}
//	r[getMax()-1]=null;// 这种是按id删除的方式，按编号删除；  【此种方法针对id形式删除】

   		System.out.println("删除成功");
   		query();
   	}

   }

   /**
    * 修改方法【缺陷，功能实现不完整】
    */
   public void modif2() {
   	System.out.println("请选择角色职业1战士2魔法师");
   	Scanner input = new Scanner(System.in);
   	int choice = input.nextInt();
   	if (choice == 1) {
   		Soldier s = new Soldier();
   		System.out.println("请输入要修改的角色名称，");
   		String name = input.next();
   		boolean flag = isNameExists(name);
   		if (flag) {
   			System.out.println("您输入的名字不存在，修改失败");

   		} else {
   			System.out.println("请确认是否修改名称y/n");
   			String ans = input.next();
   			if (ans.equals("y")) {
   				System.out.println("请输入新的昵称");
   				String name2 = input.next();
   				boolean flag2 = isNameExists(name2);
   				if (flag2) {
   					System.out.println("该昵称可用");
   					for (int i = 0; i < r.length; i++) {
   						if (r[i] != null && r[i].getName().equals(name)) {
   							r[i].setName(name2);// 此时还可以修改魔法值等信息
   						}
   					}
   					System.out.println("修改成功");
   					query();
   				} else {
   					System.out.println("您输入的名字已存在，修改失败");
   				}
   			} else {
   				System.out.println("您已取消修改，修改失败");
   			}
   		}
   	} else if (choice == 2) {
   		Magicer m = new Magicer();
   		System.out.println("请输入要修改的角色名称，");
   		String name = input.next();
   		boolean flag = isNameExists(name);
   		if (flag) {
   			System.out.println("您输入的名字不存在，修改失败");

   		} else {
   			System.out.println("请确认是否修改名称y/n");
   			String ans = input.next();
   			if (ans.equals("y")) {
   				System.out.println("请输入新的昵称");
   				String name2 = input.next();
   				boolean flag2 = isNameExists(name2);
   				if (flag2) {
   					System.out.println("该昵称可用");
   					for (int i = 0; i < r.length; i++) {
   						if (r[i] != null && r[i].getName().equals(name)) {
   							r[i].setName(name2);

   						}

   					}

   					System.out.println("修改成功");
   					query();
   				} else {
   					System.out.println("您输入的名字已存在，修改失败");
   				}
   			} else {
   				System.out.println("您已取消修改，修改失败");
   			}
   		}
   	} else {
   		System.out.println("没有该游戏类型的角色，修改失败");
   	}

   }

   /**
    * 修改方法必须用instanceof进行判断否则不能修改子类的属性找到下标后不能给子类的特有属性赋值
    */
   public void modify() {// 添加修改都必须先建立对象，
   	Role role = new Role();
   	System.out.println("角色名称");
   	Scanner input = new Scanner(System.in);
   	String inputName = input.next();
   	boolean flag1 = isNameExists(inputName);

   	if (flag1) {
   		System.out.println("角色名称不存在，修改失败");
   		return;
   	}
   	int index = getIndex(inputName);// 此时名字存在，获得其下标
   	role = r[index];// 如果存在，获得的下标赋值给该角色；
   	System.out.println("输入y确定修改角色名字");
   	String ans = input.next();
   	if (!ans.equalsIgnoreCase("y")) {
   		System.out.println("您已取消修改，修改失败");
   		return;
   	}
   	System.out.println("输入修改后的名字");
   	String name = input.next();
   	boolean flag = isNameExists(name);
   	if (!flag) {
   		System.out.println("当前名字已重复，修改失败");
   		return;
   	}
   	r[index].setName(name);
   	System.out.println("修改名字成功");
   	// 名字修改成功后再判断子类类型，修改子类的特殊属性
   	if (role instanceof Magicer) {// 修改子类特有属性，先判断是否属于，然后强转，最后把修改后的对象赋值给新建的对象
   		Magicer m =( Magicer)role;

   		System.out.println("输入y确定修改魔法等级");
   		String ans2 = input.next();
   		if (!ans.equalsIgnoreCase("y")) {
   			System.out.println("您已取消修改，修改失败");
   			return;
   		}
   		System.out.println("输入修改后的魔法等级");
   	     int level=input.nextInt();
   		m.setLevel(level);
   		r[index]=m;//这一步必须写，否则没有改变原有数组的值；把修改后的赋值给数组；
   		System.out.println("修改魔法等级成功");
   		query();
   	} else if (role instanceof Soldier) {
   		Soldier s =  (Soldier)role;
   		System.out.println("输入y确定体魄");
   		String ans2 = input.next();
   		if (!ans.equalsIgnoreCase("y")) {
   			System.out.println("您已取消修改，修改失败");
   			return;
   		}
   		System.out.println("输入修改后的体魄");
   		
   		s.setMul(input.nextInt());
   		r[index]=s;//这一步必须写，否则没有改变原有数组的值；把修改后的赋值给数组；
   		System.out.println("修改体魄成功");
   		query();
   	}
   }

   /**
    * 队伍名称判断是否重名
    * 
    */
   public int isTNameExists(String tName) {
   	int index = -1;
   	for (int i = 0; i < ts.length; i++) {
   		if (ts[i] != null & ts[i].getTName().equals(tName)) {
   			index = i;
   		}
   	}
   	return index;
   }

   /**
    *
    * 组队的方法
    */
   public void addTeam() {// 添加首先就应该建立对象
   Team   team=new Team();
   System.out.println("请输入队伍名称");//1判断队名是否重复2.给队起名；3.队伍建队用flag循环判断是否队伍已满；
   Scanner input = new Scanner(System.in);
   	String tname = input.next();
   int index=isTNameExists(tname);
   if (index==-1) {
   	System.out.println("队伍名已存在，添加失败");
   	return;
   }
   	team.setTName(tname);//名字不存在，可添加
   	Role[]ms=new Role[0];
   	boolean flag=true;
   	query();//从角色的对象数组中添加人员；
   	while (flag) {
   		System.out.println("请选择添加队员的序号");
   		int num=input.nextInt();
   		Role role=r[num-1];//相当于数组中的r[index]
   		for (int i = 0; i < ms.length; i++) {
   			if (role.getName().equals(ms[i].getName())) {
   				System.out.println("添加的名字已存在，添加失败");
   				flag=false;
   				return;
   			}
   		}
   		ms=Arrays.copyOf(ms, ms.length+1);
   		ms[ms.length-1]=role;
   		System.out.println("输入y选择继续添加");
   		String ans=input.next();
   		if (ans.equals("y")) {
   			if (ms.length<=4) {//没满可继续添加
   				flag=true;
   			}else {
   				System.out.println("队员已满，无法继续添加");
   				flag=false;
   			}
   		}else {
   			System.out.println("取消添加，队伍已建成");
   			flag=false;
   		}
   		team.setMs(ms);
   		ts = Arrays.copyOf(ts, ts.length + 1);
   		ts[ts.length - 1] = team;
   		System.out.println("队伍添加成功，您添加的队名是：" + team.getTName() + "队员信息是：");
   		for (int i = 0; i < ms.length; i++) {
   			System.out.println((i + 1) + "." + ms[i]);
   		}
   	}

   }

   /**
    *
    * 查询所有队伍的方法
    */
   public void queryTeam() {
   	if (ts.length <=0) {
   		System.out.println("当前没有队伍，查询失败");
   		return;
   	}
   	System.out.println("当前的队伍信息是：");
   	for (int i = 0; i < ts.length; i++) {
   		if (ts[i] != null) {
   			System.out.println("第" + (i + 1) + "个队伍的名字是" + ts[i].getTName() + "\n成员是：");
   			for (int j = 0; j < ts[i].getMs().length; j++) {
   				System.out.println((j+1)+ts[i].getMs()[j].showInfo() );
   			}
   		}
   	}
   }

   /**
    * 退出的方法
    * 
    */
   public void exit(String ans) {
   	Scanner input = new Scanner(System.in);
   	ans = input.next();
   	if (ans.equals("0")) {
   		System.out.println("感谢使用，远哥欢迎你再次到来");
   		System.exit(0);
   	} else {
   		menu();
   	}

   }
}
*************************************************************************************************
package cn.kgc.tyl.test0925.game.test;

import cn.kgc.tyl.test0925.game.manager.Manager;

/**
*
测试类
* */
public class TestManager {
   public static void main(String[] args) {
   	Manager m=new Manager();
   	m.initial();
   	m.menu();
   }
}
m0_45442261
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
基于Delphi+MySQL的大学生竞赛发布及组队系统.zip
10-21
资源包含文件：课程报告word+源码数据库及可执行文件+...竞赛发布及组队系统，使竞赛管理人员只需设置好竞赛信息、组队规则就可以发布竞赛，详细介绍参考：https://blog.csdn.net/sheziqiong/article/details/126702459
游戏中的物品管理系统
ybn6775的博客
03-31 3101
物品管理系统        游戏中物品管理普遍存在，各类物品的解锁与默认配置以及切换是物品管理的基本功能， 物品管理还需要支持各种物品的体验与限时免费，除此之外对于物品的获取需要记录日志系统，对于获取的量需要进行监控报警， 为而在客户端都会有物品配置的UI或场景，这些部分共同构成了整个物品管理系统。由于限时与体验物品， 导致客户端需要能够在到期后更改物品UI表现，因此物品管理系统各个部分都有紧密的...
鸿蒙操作系统能玩游戏嘛,华为鸿蒙系统能玩安卓游戏吗？-华为鸿蒙系统游戏数据怎么版？...
weixin_30928785的博客
05-27 2015
近期推出的华为系列的鸿蒙2.0很多小伙伴都在关心华为鸿蒙系统能玩安卓游戏吗？如果游戏的更新华为鸿蒙系统游戏数据怎么版？接下来小编为玩家们推荐几款鸿蒙游戏，喜欢的小伙伴可以来19游戏网下载试试看哦。刺激战场鸿蒙版是华为最新出的一个版本，相信很多玩家都期待已久这个刺激战场鸿蒙版游戏了，这不，小编就给大家带来了，这款游戏也是有着非常刺激的枪战游戏体验，还可以和好友一起进行组队，感兴趣的玩家快来下载这款刺...
机器人操作系统二（ROS2）- 修行 Taoism
zhangrelay的专栏
08-21 1万+
如果不了解ROS 2，推荐先体验一下吧，具体教程：机器人操作系统二（ROS2）- 启程 Departure ROS 2项目的目标是继承ROS 1的优点并改进不合适的部分。The goal of the ROS 2 project is to leverage what is great about ROS 1 and improve what isn’t. 何为ROS 2？Why ROS 2?...
剑网3组队系统分析
TinoTino的专栏
10-10 3011
题外话： 当一款游戏在考虑是否需要加入组队系统的时候，可多问问自己： 组队系统是否必须出现？ 玩家在不使用组队系统的情况下是否将无法继续进行游戏或者完成任务？ 确定系统出现的必要性 1、组队模式分类 剑网3 的组队系统分为小队模式与团队模式 小队 人数≤5人，可转换为团队模式 团队 人数≤25人，不可转换成小队模式 1、  在剑网3中，不组队将无法参与完成副本、日
游戏测试的概念是什么？测试方法和流程有哪些？
热门推荐
MXB_1220的博客
07-27 1万+
测试工作是，解决玩家所遇非正常问题的预测工作，同时也是不断调试平衡的一个长期观察任务。无论在什么时间段，功能实现、内测、公测等。测试都应该是分硬件与软件两部分测试。硬性问题硬件的BUG部分是指会引起不能让游戏流程进行的BUG。死机、画面出错等硬性问题。这种问题只要按照一定流程进行游戏，就会发生。但对一些会不断增加服务器负担的高级BUG，应该不会短期测试出来。而对这种在有计算机就出现的问题，现在的游戏在制作过程中都有可自动记录问题的LOG功能，所出现的BUG大多会被程序部门解决掉。部分的LOG功能可。...
多人对战游戏开发实例之《组队小鸡射击》（附源码）
03-29
游戏实现部分可拆分为三个步骤来实现：用户登录、随机匹配和创建房间及同屏游戏。 用户登录 ​使用Cocos Creator(以下简称CC)创建游戏登录场景 ​ 使用CC 拖动控件, 还原设计稿 , 依托CC的良好的工作流,使得这部分的
QT实验室管理系统-C/C++-数据结构课设
02-07
实验室管理系统 本来之前是做一个文件管理系统，后面发展了很多功能就叫实验室管理系统了。 这边只是客户端展示。 介绍 界面用的QT 5.7，之前也没接触过直接上手写了。主要是实验室几个人一起写的，研一的时候有...
推荐系统组队学习之协同过滤 - 推荐系统基础
11-24
推荐系统组队学习之协同过滤 - 推荐系统基础
从联合行为和系统动力学看人机组队
04-25
加利福尼亚圣迭戈大学论著，对人机组队技术发展现状、动向及未来进行了系统描绘
面向对象之唐城NBA选秀大会
m0_45442261的博客
09-20 4734
package cn.kgc.tyl.test0917.xuanxiu.entity; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; //0一般代表false,1代表成功 /** 球员类 */ @Data @NoArgsConstructor @AllArgsConstructor public class Player implements Comparable { pri
方法的参数传递，重载；封装；loom book的使用,注解的使用
m0_45442261的博客
09-21 1300
方法的参数传递 值类型【基本类型和特殊的String】传参，实参未发生改变；引用类型实参发生改变； ==基本类型比较的是值，引用类型比较的是地址，内容； 1、8种值类型的参数 值类型的参数：实参给形参传递的是数值，修改形参，实参根本不受影响 2、3种引用类型的参数 ①String之外的引用类型 引用类型的参数：实参给形参传递的是地址值，修改形参，相当于修改实参 ② String类型的参数 引用类型的参数：实参给形参传递的是地址值，修改形参，每次都让形参指向一个新的地址。而实参处没有修改 方法、参数传递
java面向对象oop阶段总结
m0_45442261的博客
09-30 639
名词解释 笔记0927 *对象数组起始位置可以初始化几个元素 // 1.功能五 判断队名是否重复2.给队起名；3.队伍建队用flag循环判断是否队伍已满； 2.功能六 遍历二维数组子元素的方法 *3.Role[] roles = new Role[0];// 建立角色对象数组【只有初始值为0或者初始化元素个数等于数组查高度时采用数组扩容和截取数组；否则用getMax方法获得最大实际长度，增加最后一位赋值给arr[getMax()],删除时顺次移位即可，末位清空，index+1开始 Team te
封装小Demo
m0_45442261的博客
09-23 598
package cn.kgc.tyl.test0923.entity; import lombok.NoArgsConstructor; /** *1.使用封装分别创建实体类Dog和1.使用封装分别创建实体类Dog和Penguin,其中: Dog类中 包含属性(name,love,health,strain) 方法:print()显示狗狗的信息 构造方法:无参构造函数和带参构造函数,其中: Dog类中 包含属性(name,love,health,strain) 方
封装2.0vs3.0（继承）--------loombok的缺陷
m0_45442261的博客
09-23 298
0923笔记 初始化就是赋值的意思； 用构造函数来创建对象【包括有参和无参构造】 也可以在用构造函数创建对象的同时进行给对象赋值（实例化） 封装就是属性私有化，然后提供对外的接口（方法）【建立公共的setget方法】，供外部访问和调用， final是最终的意思用在性别，数据库的密码，一周天数等固定值，修饰属性时是常量，调用属性不能再次赋值，否则报错，final的用法保证了程序的健壮性； package cn.kgc.tyl.test0923.entity; import lombok.NoArgsCons
封装与构造方法：封装必须在构造方法中限定，通过控制条件限制非法传参
m0_45442261的博客
09-22 219
package cn.kgc.tyl.test0922; import lombok.NoArgsConstructor; import lombok.ToString; /** *封装步骤：1属性私有；2setget方法【看实际需要是否添加ifelse控制语句，进行附默认值】3.在构造方法中调用修改属性的set方法； 2类图包含类名，属性 及属性的数据类型，【也可以含初始赋值】，方法名，方法的返回类型 3.实例化就是赋值，系统可以提供一个无参的默认构造，可以在无参构造中给对象赋值；也可以在无参构
String小结，StringBuffer的增删改查用法
m0_45442261的博客
09-21 216
``java package cn.kgc.tyl.test0921.entity; public class Working { private int id;//编号 private String title;//标题 private String content;//正文 private String createDate;//时间 private int type;//类型（1代表”技术”，2代表”行政”，3代表”人事”） public int getId() { return id; } publ
面向对象之抽象类总结
m0_45442261的博客
09-24 200
0924笔记 *，1在版本控制【版本迭代】过程中.如果改写Java文件复制后，要检查是否导错包 2.重写是不同类中，存在继承关系，同名同参，子类的访问权限》=父类；子类的返回值类型《=父类； 3.代码设计优化过程中，因为继承的关系，父类中的一些方法没有必要实例化，所以方法体可以省略，然后引出抽象的概念把方法改为抽象方法，让子类重写实现带有自己特点的同名方法，叫重写； 4.抽象类用abstract关键字标注，子类必须实现父类的抽象方法，所以抽象针对的是父类，并且父类一定不是private类型的【否则不能被子
h5 对人组队游戏 源码
最新发布
01-20
开发者可以编写脚本来控制角色的移动、攻击、技能释放等动作，同时还可以编写规则来管理游戏的规则和得分系统。 在组队游戏中，源码还会包含与网络连接相关的代码。通过WebSocket或者HTTP协议，玩家可以实时连接到...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

m0_45442261

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值