目录
✊前言
什么是面向对象
面向对象是写程序的套路.
面向对象介绍
- 面向:拿,找
- 对象:能干活的东西
- 面向对象编程:拿东西过来坐对应的事情
🌰面向对象编程的例子:
package org.Richard;
import java.util.Random;
import java.util.Scanner;
public class Test {
/*
这个代码其实就运用了面向对象编程思想
我利用了Random得到随机数对象,用System,还有Scanner输入
这种找东西来解决的思路就是面向对象的过程.
*/
public static void main(String[] args){
//1.得到一个随机数对象,用于得到随机数
Random r = new Random();
int data = r.nextInt(10)+1;//生成1-10之间的随机数
System.out.println(data);
//2.创建一个Scanner对象,用于接受用户输入的数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入您的年龄:");
int age = sc.nextInt();
System.out.println(age);
}
}
为什么Java会采用面向对象编程?
在我们的生活中,我们洗衣服就会用洗衣机这个工具完成,扫地我们可以用扫地机器人帮助我们完成清理,跟朋友聊天我们会用手机...
面向对象的编程思维更符合人类思维习惯,编程更简单,更好理解
面向对象的重点学习什么?
学习获取已有对象并使用(比如上面那个例子)
学习如何自己设计对象并使用(假如你现在需要一把锤子去锤螺丝钉,但是你现在身边都没有锤子,那么就需要自己去造一个,这里就会涉及面向对象的语法)
🚩面向对象学习内容
设计对象并使用
- 类和对象
对象是一个又一个能够帮助我们解决问题的东西,但是这些对象并不是凭空出现的.
比如洗衣机和扫地机器人,它们需要设计图来设计
那么在Java当中,这种设计图叫做类.
- 类(设计图):是对象共同特征的描述;
- 对象:是真实存在的具体东西(实例).
在Java中,必须先设计类,才能获得对象.
如何定义类
🌼Phone.java 代码
package org.Richard;
public class Phone {
//属性
String brand;
double price;
//行为
public void call(){
System.out.println("手机在打电话~");
}
public void playGame(){
System.out.println("手机在玩游戏~");
}
}
🌼PhoneTest.java 代码
package org.Richard;
public class PhoneTest {
public static void main(String[] args) {
//创建手机的对象
Phone p = new Phone();
p.brand = "小米";
p.price = 1999.99;
//获取手机对象中的值
System.out.println(p.brand);
System.out.println(p.price);
//调用手机中的方法即可
p.call();
p.playGame();
Phone p2 = new Phone();
p2.brand = "苹果";
p2.price = 9999;
p2.call();
p2.playGame();
}
}
- 类的几个补充注意事项
定义类的补充注意事项
- 用来描述一类事物的类,专业叫做:Javabean类.在Javabean类中,是不写main方法的.
- 在以前,编写main方法的类,叫做测试类.我们可以在测试类中创建javabean类的对象并进行赋值调用.
- 类名首字母建议大写,需要见名知意,驼峰模式.
- 一个Java文件中可以定义多个class类,且只能一个类是public修饰,而且public修饰的类名必须要成为代码文件名.
- 实际开发中建议还是一个文件定义一个class类
- 成员变量的完整定义格式是: 修饰符 数据类型 变量名称 = 初始化值;一般无序指定初始化值,存在默认值.
对象的成员变量的默认值规则
🙋🏼练习:女朋友类
编写女朋友类,创建女朋友类的对象
给女朋友的属性赋值并调用女朋友类中的方法.
思考:女朋友类中有哪些属性,有那些行为?
🌼GirlFriend 代码
public class GirlFriend {
//属性
String name;
int age;
String gender;
//行为
public void sleep(){
System.out.println("bro,My girlfriend is sleeping~");
}
public void eat(){
System.out.println("bro,My girlfriend is eating~");
}
}
🌼GirlFriendTest 代码
package org.Richard;
public class GirlFriendTest {
public static void main(String[] args) {
//创建女朋友的对象
GirlFriend gf1 = new GirlFriend();
gf1.name = "Julia";
gf1.age = 28;
gf1.gender = "female";
System.out.println(gf1.name);
System.out.println(gf1.age);
System.out.println(gf1.gender);
gf1.eat();
gf1.sleep();
System.out.println("--------");
GirlFriend gf2 = new GirlFriend();
gf2.name = "Mitchell";
gf2.age = 29;
gf2.gender = "女";
System.out.println(gf2.name);
System.out.println(gf2.age);
System.out.println(gf2.gender);
gf2.eat();
gf2.sleep();
}
}
开发中类的设计
那么我们根据这个页面我们就可以设计如下类:
public class Student {
String id;
String name;
char gender;
int age;
String schoolName;
public boolean checkID(){
...
}
}这个好像有点简单,咱来点难度😛
我们如何设计呢?
先看左边:我们需要定义四个类:班级管理,教室管理,学生管理,试卷管理.
我以试卷管理为例:
封装
如果在一个需求当中有多个事物,我们不知道把事物归属于哪一个类,我们应该怎么办?
🌰:需求:人画圆,请针对这个需求进行面向对象设计
封装是面向对象的三大特征之一,除此之外还有继承和多态
什么是封装?
告诉我们,如何正确设计对象的属性和方法
需求:定义一个类描述人
属性:姓名,年龄
行为:吃饭,睡觉
让我们看回上那个需求:人画圆,请针对这个需求进行面向对象设计
可能我们会想,画圆嘛,这个肯定是人才能画圆啦,那么应该归属到人的类中.
但其实这个应该归属到圆那个类中 啊⁉️ ⁉️ ⁉️
这里就要讲到封装思想中非常重要的原则:
对象代表什么,就得封装对应的数据,并提供数据对应的行为.
这个圆是圆自己画的.
人只是调用了圆的方法去画了一个圆而已.
如果你还不能理解,再来看一个例子: 人关门
门一定是自己关的,人只是给门一个作用力,门就自己关了
封装的好处
- 让编程变得简单,有什么事情,找对象,调方法就行.
- 降低我们的学习成本,可以少学,少记,或者说压根不用学,不用记对象有哪些方法,有需要时去找就行
我们上面写的GirlFriend类并不安全,属性可以随意更改.
Private关键字
- 是一个权限修饰符
- 可以修饰成员(成员方法和成员变量)
- 被private修饰的成员只能在本类中才能访问
安全问题就解决啦~
但是在其他类中也不能直接调用了.我们想要的是:正确的可以赋值,错误的不能赋值
你是不是在想可不可以用if来判断啊 👀
但是这样每次都判断很不方便捏
最为合理的实现操作:
总结:
- private关键字是一个权限修饰符
- 可以修饰成员(成员变量和成员方法)
- 被private修饰的成员只能在本类才能访问
- 针对private修饰的成员变量,如果需要被其他类使用,提供相应的操作
- 提供"setXxx(参数)"方法,用于给成员变量赋值,方法用public修饰
- 提供"getXxx()"方法,用于获取成员变量的值,方法用public修饰
this关键字
成员变量和局部变量
那输出谁呢?
就近原则: 谁离我近,我就用谁
this.age() 会打印成员变量
this的作用?
区分成员变量和局部变量
this的本质和内存图
后面会详细讲解.
构造方法
构造方法概述
构造方法也叫做构造器,构造函数
作用:在创建对象的时候给成员变量进行赋值的.
构造方法的格式
特点:
- 方法名与类名相同,大小写也要一致
- 没有返回值类型,连void都没有
- 没有具体的返回值(不能有return 带回结果数据)
执行时机:
- 创建对象的时候由虚拟机调用,不能手动调用构造方法
- 每创建一次对象,就会调用一次构造方法
注意:
构造方法的作用就是用来创建对象的.这句话其实是不正确的.
创建对象的时候,虚拟机会自动调用构造方法,作用是给成员变量进行初始化的.
标准的JavaBean
- 类名需要见名知意
- 成员变量使用private修饰
- 提供至少两个构造方法
- 无参构造方法
- 带全部参数的构造方法
4.成员方法
- 提供每一个成员变量对应的setXxx() / getXxx()
- 如果还有其他行为,也需要写上
package org.Richard;
public class User {
//属性
private String username;
private String password;
private String email;
private String gender;
private int age;
public User() {
}
public User(String username, String password, String email, String gender, int age) {
this.username = username;
this.password = password;
this.email = email;
this.gender = gender;
this.age = age;
}
/**
* 获取
* @return username
*/
public String getUsername() {
return username;
}
/**
* 设置
* @param username
*/
public void setUsername(String username) {
this.username = username;
}
/**
* 获取
* @return password
*/
public String getPassword() {
return password;
}
/**
* 设置
* @param password
*/
public void setPassword(String password) {
this.password = password;
}
/**
* 获取
* @return email
*/
public String getEmail() {
return email;
}
/**
* 设置
* @param email
*/
public void setEmail(String email) {
this.email = email;
}
/**
* 获取
* @return gender
*/
public String getGender() {
return gender;
}
/**
* 设置
* @param gender
*/
public void setGender(String gender) {
this.gender = gender;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "User{username = " + username + ", password = " + password + ", email = " + email + ", gender = " + gender + ", age = " + age + "}";
}
//很明显,当你的成员变量很多的时候,写Javabean就变成了一个体力活
//快捷键alt + insert
//alt + Fn + insert
// 插件PTG 1秒生成标准Javabean
}
对象内存图
- 一个对象的内存图
- 多个对象的内存图
- 两个变量指向同一个对象内存图
- this的内存原理
- 基本数据类型和引用数据类型的区别
- 局部变量和成员变量的区别
基本数据类型和引用数据类型
this的内存原理
补充知识:成员变量,局部变量区别
面向对象综合案例
文字版格斗游戏
格斗游戏,每个有些角色的姓名,血量,都不相同,在选定任务的时候(new对象的时候),这些信息就应该被确定下来.
Role 类
package org.Richard;
import java.util.Random;
public class Role {
private String name;
private int blood;
public Role() {
}
public Role(String name, int blood) {
this.name = name;
this.blood = blood;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return blood
*/
public int getBlood() {
return blood;
}
/**
* 设置
* @param blood
*/
public void setBlood(int blood) {
this.blood = blood;
}
public String toString() {
return "Role{name = " + name + ", blood = " + blood + "}";
}
//定义一个方法用于攻击别人
//思考:谁攻击谁?
//Role r1 = new Role();
//Role r2 = new Role();
//r1.攻击(r2);
//方法的调用者去攻击参数
public void attack(Role role){
//计算造成的伤害 1 ~ 20
Random r = new Random();
int hurt = r.nextInt(20)+1;
//剩余血量
int remainBoold = role.getBlood()-hurt;
//对剩余血量做一个验证,如果为负数了,就修改为0
remainBoold = remainBoold < 0?0:remainBoold;
//修改一下挨揍人的血量
role.setBlood(remainBoold);
//this表示方法的调用者
System.out.println(this.getName()+"举起拳头,打了"+role.getName()+"一下"+"造成了"+hurt+"点伤害," +
role.getName()+"还剩下"+remainBoold+"点血");
}
}
GameTest 类
public class GameTest {
public static void main(String[] args) {
//1.创建第一个角色
Role r1 = new Role("乔峰",100);
//2.创建第二个角色
Role r2 = new Role("鸠摩智",100);
//3.开始格斗 回合制游戏
while(true){
//r1开始攻击r2
r1.attack(r2);
//判断r2的剩余血量
if(r2.getBlood()== 0){
System.out.println(r1.getName()+"K.O"+r2.getName());
break;
}
//r2开始攻击r1
r2.attack(r1);
//判断r2的剩余血量
if(r1.getBlood()== 0){
System.out.println(r2.getName()+"K.O"+r1.getName());
break;
}
}
}
}
学习printf
public static void main(String[] args) {
//两部分参数:
//第一部分参数:要输出的内容:%s(占位)
//第二部分参数:填充的数据
System.out.printf("你好啊%s","yjy");
System.out.printf("%s你好啊%s","张三","李四");
}Role 类
package org.Richard;
import java.util.Random;
public class Role {
private String name;
private int blood;
private char gender;
private String face;//长相是随机的
String[] boyfaces= {"风流俊雅","气宇轩昂","相貌英俊","五官端正","相貌平平","一塌糊涂","面目狰狞"};
String[] girlfaces ={"美奂绝伦","沉鱼落雁","婷婷玉立","身材娇好","相貌平平","相貌简陋","惨不忍睹"};
//attack 攻击描述：
String[] attacks_desc={
"%s使出了一招【背心钉】，转到对方的身后，一掌向%s背心的灵台穴拍去。",
"%s使出了一招【游空探爪】，飞起身形自半空中变掌为抓锁向%s。",
"%s大喝一声，身形下伏，一招【劈雷坠地】，捶向%s双腿。",
"%s运气于掌，一瞬间掌心变得血红，一式【掌心雷】，推向%s。",
"%s阴手翻起阳手跟进，一招【没遮拦】，结结实实的捶向%s。",
"%s上步抢身，招中套招，一招【劈挂连环】，连环攻向%s。"
};
//injured 受伤描述：
String[] injureds_desc={
"结果%s退了半步，毫发无损",
"结果给%s造成一处瘀伤",
"结果一击命中，%s痛得弯下腰",
"结果%s痛苦地闷哼了一声，显然受了点内伤",
"结果%s摇摇晃晃，一跤摔倒在地",
"结果%s脸色一下变得惨白，连退了好几步",
"结果『轰』的一声，%s口中鲜血狂喷而出",
"结果%s一声惨叫，像滩软泥般塌了下去"
};
public Role() {
}
public Role(String name, int blood,char gender) {
this.name = name;
this.blood = blood;
this.gender = gender;
//随机长相
setFace(gender);
}
public Role(String name, int blood, char gender, String face, String[] boyfaces, String[] girlfaces) {
this.name = name;
this.blood = blood;
this.gender = gender;
this.face = face;
this.boyfaces = boyfaces;
this.girlfaces = girlfaces;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return blood
*/
public int getBlood() {
return blood;
}
/**
* 设置
* @param blood
*/
public void setBlood(int blood) {
this.blood = blood;
}
public String toString() {
return "Role{name = " + name + ", blood = " + blood + "}";
}
//定义一个方法用于攻击别人
//思考:谁攻击谁?
//Role r1 = new Role();
//Role r2 = new Role();
//r1.攻击(r2);
//方法的调用者去攻击参数
public void attack(Role role){
//输出一个攻击的效果
Random r = new Random();
int index = r.nextInt(attacks_desc.length);
String kungFu = attacks_desc[index];
System.out.printf(kungFu,this.getName(),role.getName());
System.out.println();
//计算造成的伤害 1 ~ 20
int hurt = r.nextInt(20)+1;
//剩余血量
int remainBoold = role.getBlood()-hurt;
//对剩余血量做一个验证,如果为负数了,就修改为0
remainBoold = remainBoold < 0?0:remainBoold;
//修改一下挨揍人的血量
role.setBlood(remainBoold);
//this表示方法的调用者
//受伤的描述
//血量 > 90 0索引的描述
// 80 ~ 90 1索引的描述
// 70 ~ 80 2索引的描述
// 60 ~ 70 3索引的描述
// 40 ~ 60 4索引的描述
// 20 ~ 40 5索引的描述
// 10 ~ 20 6索引的描述
// 小于10的 7索引的描述
if(remainBoold > 90){
System.out.printf(injureds_desc[0],role.getName());
} else if (remainBoold > 80 && remainBoold <= 90) {
System.out.printf(injureds_desc[1],role.getName());
}else if (remainBoold > 70 && remainBoold <= 80) {
System.out.printf(injureds_desc[2],role.getName());
}else if (remainBoold > 60 && remainBoold <= 70) {
System.out.printf(injureds_desc[3],role.getName());
}else if (remainBoold > 40 && remainBoold <= 60) {
System.out.printf(injureds_desc[4],role.getName());
}else if (remainBoold > 20 && remainBoold <= 40) {
System.out.printf(injureds_desc[5],role.getName());
}else if(remainBoold >10 && remainBoold<=20){
System.out.printf(injureds_desc[6],role.getName());
}else{
System.out.printf(injureds_desc[7],role.getName());
}
System.out.println();
}
/**
* 获取
* @return gender
*/
public char getGender() {
return gender;
}
/**
* 设置
* @param gender
*/
public void setGender(char gender) {
this.gender = gender;
}
/**
* 获取
* @return face
*/
public String getFace() {
return face;
}
/**
* 设置
* @param gender
*/
public void setFace(char gender) {
Random r = new Random();
//长相是随机的
if(gender == '男'){
//从boyfaces里面随机长相
int index = r.nextInt(boyfaces.length);
this.face = boyfaces[index];
}else if(gender == '女'){
//从girlfaces里面随机长相
int index = r.nextInt(girlfaces.length);
this.face = girlfaces[index];
}else{
this.face = "面目狰狞";
}
}
public void showRoleInfo(){
System.out.println("姓名为:" + getName());
System.out.println("血量为:" + getBlood());
System.out.println("性别为:"+getGender());
System.out.println("长相为:"+getFace());
}
}
GameTest 类
package org.Richard;
public class GameTest {
public static void main(String[] args) {
//1.创建第一个角色
Role r1 = new Role("乔峰",100, '男');
//2.创建第二个角色
Role r2 = new Role("鸠摩智",100,'男');
//展示一下角色的信息
r1.showRoleInfo();
r2.showRoleInfo();
//3.开始格斗 回合制游戏
while(true){
//r1开始攻击r2
r1.attack(r2);
//判断r2的剩余血量
if(r2.getBlood()== 0){
System.out.println(r1.getName()+"K.O"+r2.getName());
break;
}
//r2开始攻击r1
r2.attack(r1);
//判断r2的剩余血量
if(r1.getBlood()== 0){
System.out.println(r2.getName()+"K.O"+r1.getName());
break;
}
}
}
}
案例:对象数组1
定义数组存储3个商品对象.
商品的属性:商品的id,名字,价格,库存.
创建三个商品对象,并把商品对象存入到数组当中.
package org.Richard;
public class GoodsTest {
public static void main(String[] args) {
//1.创建一个数组
Goods[] arr = new Goods[3];
//2.创建三个商品对象
Goods g1 = new Goods("001","华为P40",5999.0,1000);
Goods g2 = new Goods("002","保温杯",222.0,10);
Goods g3 = new Goods("003","枸杞",2.0,80);
//3.把商品添加到数组中
arr[0] = g1;
arr[1] = g2;
arr[2] = g3;
//4.遍历
for (int i = 0; i < arr.length; i++) {
//i 索引 arr[i] 元素
Goods goods = arr[i];
System.out.println(goods.getId() +", "+goods.getName()+", "+goods.getPrice()+", "+goods.getCount());
}
}
}
对象数组2
定义数组存储3部汽车对象
汽车的属性:品牌,价格,颜色
创建三个汽车对象,数据通过键盘录入而来,并把数据存入到数组当中.
Car 类
package org.Richard;
public class Car {
private String brand;//品牌
private int price;//价格
private String color;//颜色
public Car() {
}
public Car(String brand, int price, String color) {
this.brand = brand;
this.price = price;
this.color = color;
}
/**
* 获取
* @return brand
*/
public String getBrand() {
return brand;
}
/**
* 设置
* @param brand
*/
public void setBrand(String brand) {
this.brand = brand;
}
/**
* 获取
* @return price
*/
public int getPrice() {
return price;
}
/**
* 设置
* @param price
*/
public void setPrice(int price) {
this.price = price;
}
/**
* 获取
* @return color
*/
public String getColor() {
return color;
}
/**
* 设置
* @param color
*/
public void setColor(String color) {
this.color = color;
}
public String toString() {
return "Car{brand = " + brand + ", price = " + price + ", color = " + color + "}";
}
}
CarTest 类
package org.Richard;
import java.util.Scanner;
public class CarTest {
public static void main(String[] args) {
//1.创建一个数组用来存3个汽车对象
Car[] arr = new Car[3];
//2.创建汽车对象,数据来自键盘录入
int length_car = arr.length;
Scanner sc = new Scanner(System.in);
for(int i = 0;i<length_car;i++){
//创建汽车的对象
Car c = new Car();
//录入品牌
System.out.println("请输入汽车的品牌:");
String brand = sc.next();
c.setBrand(brand);
//录入价格
System.out.println("请输入汽车的价格:");
int price = sc.nextInt();
c.setPrice(price);
//录入颜色
System.out.println("请输入汽车的颜色:");
String color = sc.next();
c.setColor(color);
//把汽车对象添加到数组当中
arr[i] = c;
}
//遍历数组
for(int i = 0;i<length_car;i++){
Car car = arr[i];
System.out.println(car.toString());
}
}
}
再来一个案例:
Student 类
package org.Richard;
public class Student {
private int id;
private String name;
private int age;
public Student() {
}
public Student(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
/**
* 获取
* @return id
*/
public int getId() {
return id;
}
/**
* 设置
* @param id
*/
public void setId(int id) {
this.id = id;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "Student{id = " + id + ", name = " + name + ", age = " + age + "}";
}
}StudentTest类
package org.Richard;
public class StudentTest {
public static void main(String[] args) {
//1.创建一个数组来存储学生对象
Student[] arr = new Student[3];
//2.创建学生对象并添加到数组当中
Student stu1 = new Student(1,"zhangsan",23);
Student stu2 = new Student(2,"lisi",24);
Student stu3 = new Student(3,"wangwu",25);
//3.把学生对象添加到数组当中
arr[0] = stu1;
arr[1] = stu2;
arr[2] = stu3;
//要求1:再次添加一个学生对象,并在添加的时候进行学号的唯一性判断.
//读题拆解法
Student stu4 = new Student(4,"zhaoliu",26);
//唯一性判断
//已存在 -- 不用添加
//不存在 -- 就可以把学生对象添加进数组
boolean flag = contains(arr,stu4.getId());
if(flag){
System.out.println("当前id重复,请修改id后再进行添加");
}else{
}
//把stu4添加到数组当中
//1.数组已经存满 -- 只能创建一个新的数组,新数组的长度 = 老数组 + 1
//2.数组没有存满 -- 直接添加
int count = getCount(arr);
if(count==arr.length){
//已经存满
//创建一个新的数组,长度 = 老数组的长度 + 1
//然后把老数组的元素,拷贝到新数组
Student[] newArr = creatNewArr(arr);
//添加stu4
newArr[count] = stu4;
printArr(newArr);
}else{
//没有存满
//[stu1,stu2,null]
//getCount获取到的是2,表示数组当中已经有了2个元素
//还有一层意思:如果下一次要添加数据,就是添加到2索引的位置
arr[count] = stu4;
printArr(arr);
}
//要求2:添加完毕之后,遍历所有学生信息
//要求3:通过id删除学生信息
//如果存在,则删除,如果不存在,则提示删除失败
//要找到id在数组中对应的索引
int index = getIndex(arr, 2);
if(index>0){
arr[index] = null;
printArr(arr);
}else{
System.out.println("删除失败");
}
//要求4:删除完毕之后,遍历所有学生信息.
//要求5:查询数组id为"2"的学生,如果存在,则将他的年龄+1岁
int index1 = getIndex(arr,2);
//判断索引
if(index1>=0){
int age = arr[index1].getAge()+1;
arr[index1].setAge(age);
}else{
System.out.println("不存在,修改失败");
}
printArr(arr);
}
//1.我要干嘛? 找到id在数组中的索引
//2.我需要什么? 数组 id
//3.调用处是否需要继续使用方法的结果? 要
public static int getIndex(Student[] arr,int id){
for (int i = 0; i < arr.length; i++) {
Student stu = arr[i];
if(stu!=null){
int sid = stu.getId();
if(sid==id){
return i;
}
}
}
return -1;
}
public static void printArr(Student[] arr){
for (int i = 0; i < arr.length; i++) {
Student stu = arr[i];
if(stu!=null){
System.out.println(stu.getId()+", "+stu.getName()+", "+stu.getAge());
}
}
}
public static Student[] creatNewArr(Student[] arr){
Student[] newArray = new Student[arr.length+1];
//循环遍历得到老数组的每一个元素
for(int i = 0;i<arr.length;i++){
newArray[i] = arr[i];
}
return newArray;
}
//定义一个方法判断数组中已经存了几个元素
public static int getCount(Student[] arr){
//定义一个计数器用来统计
int count = 0;
for (int i = 0; i < arr.length; i++) {
if(arr[i] != null){
count++;
}
}
return count;
}
//1.我要干嘛?
//2.我要干这件事情,需要什么才能完成? 数组 id --> 形参
//3.调用处是否需要继续使用方法的结果? 必须返回
public static boolean contains(Student[] arr,int id){//1 2 3 --- 3是否存在
for (int i = 0; i < arr.length; i++) {
//依次获取到数组里面的每一个学生对象
Student stu = arr[i];
//获取数组中学生的id
int sid = stu.getId();
//比较
if(sid == id){
return true;
}
}
return false;
}
}
3009
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
