OOP⑷
Posted 我可不是隔壁的老王
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了OOP⑷相关的知识，希望对你有一定的参考价值。
1.对象数组：
/**
*学生类
*/
public class Student {
// 创建一个对象数组保存3名学生的信息
Student[] stus = new Student[3];
int age; // 年龄
String name; // 姓名
/**
* 无参构造
*/
public Student() {
}
/**
* 带参构造
*/
public Student(int age, String name) {
this.age = age;
this.name = name;
}
/**
* 循环给对象数组中的每一个元素 赋值
* @param stus 用户传递过来的对象数组
*/
public void addStudent() {
Scanner input = new Scanner(System.in);
for (int i = 0; i < stus.length; i++) {
System.out.println("请您给第" + (i + 1) + "个学生赋值：");
// 需要给数组中的每一个元素对象 实例化
stus[i] = new Student();
System.out.println("姓名：");
stus[i].name = input.next();
System.out.println("年龄：");
stus[i].age = input.nextInt();
}
}
/**
* @param students 需要遍历的数组名称
*/
public void showStudent() {
System.out.println("所有的学生信息显示如下：");
for (Student stu : stus) {
System.out.println(stu.name + ":" + stu.age);
}
}
/**
* 查询学生
*/
public void finStudent(int begin, int end, String name) {
// 定义一个标记
boolean flag = false;
for (int i = begin - 1; i < end; i++) {
if (stus[i].name.equals(name)) {
flag = true; // 找到了 为true
break;
}
}
if (flag) {
System.out.println("找到了");
} else {
System.out.println("您查询的学生不存在！");
}
}
/**
* @param oldName 学生以前的姓名
* @param newName 更改之后的姓名
*/
public void changeName(String oldName, String newName) {
// 定义一个标记 看是否更改成功
boolean flag = false;
for (int i = 0; i < stus.length; i++) {
if (stus[i].name.equals(oldName)) {
stus[i].name = newName;
flag = true;
break;
}
}
if (flag) {
System.out.println("修改成功");
} else {
System.out.println("没有找到！无法修改");
}
}
}
public class StudentTest {
/**
* 需求：
* 01.现在有3名学生！创建一个对象数组保存这3名学生的信息！并且输出！
* 02.让用户输入一个开始和结束位置！以及学生的姓名！ 我们判断是否有该学生！
*
*
* 分析：
* 01.3名学生，每一个学生都是一个对象！那么第一步创建一个学生类！！！
* 并且 给类中增加属性和构造方法
* 02.什么是数组？ 一组相同数据类型的数据集合！
* int [] nums=new int[3];
*
* 什么是对象数组？
* 3名学生 是3个对象！ 类型一样，类型都是Student类型！
* Student [] students=new Student[3];
* 现在students数组中的每一个元素 是什么？
* students[0] 是一个Student对象！
* students[1] 是一个Student对象！
* students[2] 是一个Student对象！
* 03.怎么给对象数组中的每一个元素（Student对象）的属性赋值呢？
* 前提 每一个元素 都需要实例化！
* 因为这个对象数组中的每一个元素 不再是普通的数值了，而是一个Student类型的对象！
* 对象没有实例化，是不能使用的！
* 否则会产生NullPointerException（空指针异常）
* null.不出来任何东西！
*/
public static void main(String[] args) {
// 实例化Student类
Student stu = new Student();
stu.addStudent(); // 循环新增学生信息
// 看到输入的所有 学生信息
stu.showStudent();
// 根据开始和结束位置，去数组中查询 有没有该学生
Scanner input = new Scanner(System.in);
System.out.println("请输入开始查询的位置：");
int begin = input.nextInt();
System.out.println("请输入结束查询的位置：");
int end = input.nextInt();
System.out.println("请输入查询的学生姓名：");
String name = input.next();
// 根据用户的输入找到指定的学生
stu.finStudent(begin, end, name);
System.out.println("请输入需要修改的学生姓名：");
String oldName = input.next();
System.out.println("请输入新姓名：");
String newName = input.next();
stu.changeName(oldName, newName);
// 看到输入的所有 学生信息
stu.showStudent();
}
}
2.封装：
/**
* 学生类
*
* 面向对象的三大特性！
* 01.封装
* 概念：将类的某些信息隐藏在类内部！不允许其他类直接访问，而是通过该类提供的方法来访问隐藏的信息！
* 目的：隐藏类的内部细节！ 安全！
*
* 步骤：
* 001.把所有的属性 私有化
* 002.创建属性对应的set和get方法 shift +alt +s +r 快速生成类中所有变量的set和get方法
* 003.在对应的set或者get方法中 增加逻辑判断！确保数据的有效性！
*
*
* 02.继承
* 03.多态
*
*/
public class Student {
private int age; // 年龄
private String name; // 姓名
private char sex; // 性别
/**
* get() 是为了别人获取值
* set() 是为了给属性赋值
* shift +alt +s +r 快速生成类中所有变量的set和get方法
*
*/
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public char getSex() {
return sex;
}
/**
* @param sex 用户传递来的 用户性别
* 如果用户输入的是不健康的数据！
* 我们默认sex=‘男‘
*/
public void setSex(char sex) {
if (sex == ‘男‘ || sex == ‘女‘) {
this.sex = sex;
} else {
// 不健康输入
this.sex = ‘男‘;
}
}
}
public class StudentTest {
public static void main(String[] args) {
Student stu = new Student();
stu.setSex(‘c‘); // í¨1yset()ê?D??3?μ
// í¨1yget()è??μ
System.out.println(stu.getSex());
}
}
/**
* 学生类
*/
public class Student {
int age; // 年龄
String name; // 姓名
/**
* shift +alt +s +o 快捷键 生成 有参和无参构造
*/
public Student(int age, String name) {
super();
this.age = age;
this.name = name;
}
public Student() {
super();
}
/**
* 学生自我介绍的方法
*/
public void showInfo() {
System.out.println("我的姓名是：" + name);
System.out.println("我的年龄是：" + age);
}
public void showInfo(Student stu) {
stu.age = 888; // 改变参数的值
stu.name = "小白";
System.out.println("参数的姓名是：" + stu.name);
System.out.println("参数的年龄是：" + stu.age);
}
/**
* 学生睡觉的方法
*/
public void sleep() {
System.out.println(name + "在睡觉");
}
/**
* @param stu 用户传递来的学生对象
* @return 是否长大了
*/
public void changeStudent(Student stu) {
// 定义一个标记
boolean flag = false;
if (stu.age > 20) {
flag = true;
}
if (flag) {
System.out.println("你已经长大了！");
} else {
System.out.println("你还年轻！");
}
}
}
public class StudentTest {
public static void main(String[] args) {
// 创建学生类对象
Student stu = new Student();
stu.age = 20;
stu.name = "小黑";
// 自我介绍
stu.showInfo();
// 调用对象的睡觉方法
stu.sleep();
System.out.println("----------------------------");
stu.showInfo(stu);
// 调用学生是否长大的方法
stu.changeStudent(stu);
}
}
/**
* 方法重载
* 01.在一个类中
* 02.方法名相同
* 03.参数列表不同
* 04.与方法的修饰符和返回值类型 无关！
*
*
* 其实就是一个静态的多态！
* 都是买东西，但是根据传递参数的不同得到一个不同的结果！
*/
public class Student {
int age;
/**
* 构造的重载
*/
public Student() {
}
public Student(int age) {
this.age = age;
}
/**
* 买东西 什么都不给
*/
public void buy() {
}
/**
* 买东西 给钱 没找零
*/
public void buy(double money) {
}
/**
* 买东西 给钱 ,给东西
*/
public void buy(double money, String someThing) {
}
}
/**
* 一个类在被jvm加载的时候，首先会加载类中所有由static修饰的方法，属性，代码块！
* 并把这个数据放进堆中的静态存储区！便于我们访问！
*
* static 可以修饰的内容
* 01.属性 静态属性
* 02.方法 静态方法
* 03.代码块 静态代码块
*
*
* 特点：
* 01. 有static修饰的内容，在整个程序运行期间，只存在一份！
* 02. 有static修饰的属性和方法，直接可以通过类名.属性 /类名.方法
* 03. static修饰的方法中 不能访问 非static修饰的的属性！
* 04.非static修饰的方法中能访问 static修饰的的属性！
*
*
* 例子：
* 之前说过 一个类可以创建N个对象！
* 每个对象都是独一无二的！
*
* 现在 我们实现N个对象 共享一个属性！
*
*/
public class Student {
static int age; // 静态变量
String name;
/**
* 创建一个static修饰的静态方法
* 之前的方式：
* 01.通过类创建对象
* 02.通过对象.方法访问
*
* 现在
* 直接通过类名.方法
*/
public static void sayHello() {
System.out.println("我是一个静态方法");
}
public static void main(String[] args) {
Student stu1 = new Student();
stu1.age = 50;
stu1.name = "小黑";
Student stu2 = new Student();
stu2.age = 30;
stu2.name = "小白";
System.out.println("stu1的年龄：" + stu1.age);
System.out.println("stu2的年龄：" + stu2.age);
System.out.println("stu1的姓名：" + stu1.name);
System.out.println("stu2的姓名：" + stu2.name);
/**
* 在 age前 加一个修饰符 static
* 虽然没有给stu3对象的age属性赋值！
* 但是因为age是static修饰的！
* 所以所有对象共享这个属性！
* 只要有一个对象改变了这个age属性！
* 那么所有对象的这个age属性都随之发生变化！
*/
Student stu3 = new Student();
stu3.age = 60;
System.out.println("stu3的年龄：" + stu3.age);
Student.sayHello();
}
}
/**
* 验证静态代码块和普通代码块的执行顺序
* 静态代码块优先执行！
*
* 如果有多个静态代码块或者普通代码块
* 按照书写的顺序执行！
*/
public class StaticBlock {
public StaticBlock() {
System.out.println(" 无参构造");
}
{
System.out.println("普通代码块1");
}
{
System.out.println("普通代码块2");
}
static {
System.out.println("静态代码块1");
}
static {
System.out.println("静态代码块2");
}
public static void main(String[] args) {
// 实例化对象
StaticBlock s = new StaticBlock();
}
}
/**
* 书写实体类的步骤
* 01.定义属性
* 02.快捷键生成set get
* 03.快捷键生成 有参 无参构造
* 04.生成toString()
*/
public class Student {
private int age;
private String name; // 属性
/**
* set和get方法名称后的第一个单词 首字母小写 ===》属性名
*
* 01.this调用本类的构造方法时，只能存在构造方法中的第一行！
* 02.this还可以访问我们的属性和方法 可以存在任何位置！
*/
public Student() {
this(50, "小黑"); // 调用本类的带参构造
}
public Student(int age, String name) {
// this(); 调用本类的无参构造
this.age = age;
this.name = name;
}
// set get方法
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class StudentTest {
public static void main(String[] args) {
Student stu = new Student();
System.out.println(stu.getName());
System.out.println(stu.getAge());
}
}
以上是关于OOP⑷的主要内容，如果未能解决你的问题，请参考以下文章