oop01
面向对象01
package cn.bdqn.bean;
/** 学生类
*
* class：关键字，就是用来修饰类名！
*
* 万物皆对象！
*
* 类是对象的抽象/模版！
* 对象是类的具体/实例！
*
* 具有相同的属性和行为的集合！我们就可以抽象出来一个类===》学生类
*
* 学生类 能创建出来 多个 学生对象！
*
* 类名必须 满足 帕斯卡命名法！
* 属性名 和方法名 都满足 驼峰命名法
*/
public class Student {
/**
* 属性
* 成员变量：如果没有赋值，则有默认值！
*
* 访问修饰符：
* 01.public 公共的！所有的类都可以访问
* 02.private 私有的！只能在本类中使用！
* 03.protected: 受保护的！只能在子类中访问！
* 04.default: 默认的！ 本包中的类 可以访问！
*/
public String name; // 学生的姓名
public int age; // 学生的年龄
public char sex; // 学生的性别
/**
* Student类中的无参构造
* 如果我们没有显示的写出
* 那么 系统会 默认创建类的无参构造
* 格式：
* 访问修饰符 类名（）｛
* ｝
*/
public Student() {
System.out.println("执行了 Student类中的无参构造");
}
/**
* 带参构造 如果没有创建对应的无参构造
* 这个时候 系统不会默认创建无参构造
* Student stu=new Student();就会编译报错
*/
public Student(String name, int age, char sex) {
System.out.println("执行了 Student类中的带参构造");
// 用户传来的值 赋值给 成员变量
this.name = name;
this.age = age;
this.sex = sex;
}
/**
* 学习的方法
* public：代表方法的访问权限，最宽松的一个！ 所有的类都可以访问这个方法
* void：方法的返回值类型 没有返回值 就是 void
* study:方法名
*/
public void study() {
System.out.println(name + "在学习!");
}
public void sleep() {
System.out.println(name + "在睡觉！");
}
/**
* 自我介绍的方法
*/
public void sayHello() {
/**
* 给全局变量赋值
* 如果下面的赋值语句放到 局部变量之后，相当于给局部变量重新赋值
*/
age = 50;
sex = '女';
/**
* 局部变量
*/
char sex = '男';
int age = 5;
System.out.println("我的姓名是：" + name);
System.out.println("我的性别是：" + sex);
System.out.println("我的年龄是：" + age);
}
}
public class StudentTest {
public static void main(String[] args) {
/**
* 01.怎么创建出 对象？？
* 类名 对象名 = new 类名();
*
* 02.怎么调用对象的行为或者属性？？
* 对象名.方法
* 对象名.属性 全局的变量
*/
Student stu1 = new Student(); // 默认回调用Student类中的 无参构造方法
stu1.name = "李四"; // 相当于给stu1对象的name属性 赋值
// 调用对象的sayHello（）
stu1.sayHello();
System.out.println(stu1.sex); // 输出的是全局变量sex
}
@Test
public void test01() {
// 调用带参构造 创建对象的同时 给 对象属性 赋值
Student stu = new Student("小白", 50, '男');
System.out.println(stu.name);
System.out.println(stu.age);
System.out.println(stu.sex);
System.out.println("***************************");
// 调用无参构造 创建一个对象
Student stu2 = new Student();
System.out.println(stu2.name);
System.out.println(stu2.age);
System.out.println(stu2.sex);
}
}
/**
* 实现学生的信息管理
*/
public class StudentBiz {
// 创建一个数组 用来保存 所有学生的姓名
String[] names = new String[10];
/**
* 新增学生姓名的方法
* @param name :用户传递过来的 参数
* 01.循环我们事先定义好的 数组
* 02.发现数组中有null的元素，证明 可以新增数据
* 03.把用户传递过来的名称 放到元素为null的位置
*/
private void addStudentName(String name) {
for (int i = 0; i < names.length; i++) {
if (names[i] == null) {
names[i] = name;
break;
}
}
}
/**
* 显示所有学生的姓名
*/
private void showStudentNames() {
for (int i = 0; i < names.length; i++) {
if (names[i] != null) {
System.out.println(names[i]);
}
}
}
/**
* 修改学生姓名，输入新、旧姓名，进行修改并显示是否修改成功
* @param oldName 旧姓名
* @param newName 新姓名
* @return 是否修改成功
*/
public boolean updateName(String oldName, String newName) {
// 定义一个标记
boolean flag = false;
for (int i = 0; i < names.length; i++) {
if (names[i].equals(oldName)) { // 证明可以修改姓名
names[i] = newName;
flag = true;
break;
}
}
return flag;
}
/**
* 设计方法，通过传递三个参数（开始位置、结束位置、查找的姓名）
来实现查询 指定学生姓名
* @param begin 开始位置
* @param end 结束位置
* @param name 查找的姓名
* @return 是否找到指定的学生
*/
public boolean findName(int begin, int end, String name) {
// 定义一个标记 默认没有找到
boolean flag = false;
for (int i = begin - 1; i < end; i++) {
if (names[i].equals(name)) { // 找到了
flag = true;
break;
}
}
return flag;
}
/**
* 测试方法
*/
public static void main(String[] args) {
StudentBiz stu = new StudentBiz();
Scanner scanner = new Scanner(System.in);
// 循环给学生的姓名 赋值
for (int i = 1; i <= 3; i++) {
System.out.println("请您输入第" + i + "个学生的姓名：");
String name = scanner.next();
// name 称之为 实参！ 实际传递的参数
stu.addStudentName(name); // 调用学生类中 新增学生姓名的方法
}
// 显示所有学生的姓名
stu.showStudentNames();
System.out.println("请您输入从哪个位置开始查询：");
int begin = scanner.nextInt();
System.out.println("请您输入到哪个位置结束查询：");
int end = scanner.nextInt();
System.out.println("请您输入查询的学生姓名：");
String name = scanner.next();
// 调用查询的方法
if (stu.findName(begin, end, name)) {
System.out.println("找到了！");
} else {
System.out.println("没有找到！");
}
System.out.println("请您输入需要修改的学生姓名：");
String oldName = scanner.next();
System.out.println("请您输入修改之后的姓名：");
String newName = scanner.next();
// 调用修改姓名的方法
if (stu.updateName(oldName, newName)) {
System.out.println("修改成功！");
} else {
System.out.println("修改失败！");
}
}
}
public class ScoreTest {
/**
* 用户只会关注我们的功能，不会去关注底层的代码实现！
* 我们也没有必要把代码给用户观看！
*/
public static void main(String[] args) {
double[] scores = new double[5];
getScores(scores); // 循环赋值
System.out.println("平均分是：" + getAvg(scores)); // 平均分
System.out.println("最高分是：" + getMaxScore(scores)); // 最大值
}
/**
* @param scores 用户传递过来的集合
* @return 集合中的最大值
*/
private static double getMaxScore(double[] scores) {
// 先定义一个擂主
double max = scores[0];
for (int i = 0; i < scores.length; i++) {
if (scores[i] > max) {
max = scores[i];
}
}
return max;
}
/**
* 平均分
* @param scores 用户传递过来的集合
*/
private static double getAvg(double[] scores) {
double sum = 0; // 记录总成绩
for (int i = 0; i < scores.length; i++) {
sum += scores[i];
}
return sum / scores.length; // 返回平均分
}
/**
* 循环给学生成绩赋值
* @param scores 用户传递过来的集合
*/
private static void getScores(double[] scores) {
Scanner scanner = new Scanner(System.in);
for (int i = 0; i < scores.length; i++) {
System.out.println("请输入第" + (i + 1) + "个学生的成绩：");
scores[i] = scanner.nextDouble();
}
}
}
/**
* 模拟银行存款 取款功能
*/
public class AccountTest {
public static void main(String[] args) {
// 定义一个标记 用来记录用户是否退出系统
boolean flag = true;
// 创建银行账户的对象
Account account = new Account();
do {
System.out.println("1.存款\t\t2.取款\t\t0.退出");
System.out.println("请您输入选择：");
Scanner scanner = new Scanner(System.in);
int choose = scanner.nextInt(); // 获取用户的输入
switch (choose) {
case 0:
flag = false;
System.out.println("感谢您的使用！");
break;
case 1: // 存款
System.out.println("请您输入存款的金额：");
double money = scanner.nextDouble();
account.saveMoney(money);// 调用存款的方法
break;
case 2: // 取款
System.out.println("请您输入取款的金额：");
double goMoney = scanner.nextDouble();
account.goMoney(goMoney);// 调用取款的方法
break;
}
} while (flag);
}
}
/**
* 银行的实体类
*/
public class Account {
double money = 0; // 默认初始化金额为0
/**
* 存款的方法
* @param money2存款的金额
*/
public void saveMoney(double money2) {
money += money2;
System.out.println("存款成功！");
System.out.println("当前的余额是：" + money);
}
/**
* 取款的方法
* @param money2 取款金额
*/
public void goMoney(double money2) {
if (money2 > money) { // 余额不足
System.out.println("余额不足！！ 退出系统");
} else {
money -= money2;
System.out.println("取款成功");
}
System.out.println("当前的余额是：" + money);
}
}
public class OverTest {
/**
* 方法重载：
* 01.保证所有的方法在同一个类中
* 02.方法名称一致
* 03.参数列表不同（参数的类型，个数，参数的顺序 之间是或者的关系）
* 04.与方法的访问修饰符以及返回值类型 无关
*/
public static void main(String[] args) {
int num1 = 50;
double num2 = 50;
int num3 = 100;
String name = "小黑";
getSum(num1, num2);
getSum(num1, num3); // int类型的num3自动类型转换成double
getSum(num1, name);
getSum(name, num1);
}
private static void getSum(String name, int num1) {
System.out.println("getSum(String,int)==" + name);
}
private static void getSum(int num1, String name) {
System.out.println("getSum(int,String)==" + name);
}
private static void getSum(int num1, double num2) {
System.out.println("getSum(int,double)==" + (num1 + num2));
}
private static void getSum(int num1, int num2) {
System.out.println("getSum(int,int)==" + (num1 + num2));
}
public static String getSum() {
return "getSum()";
}
}
/**
* 方法重载：
* 01.在同一个类中
* 02.方法名相同
* 03.参数列表不同 （参数的类型，参数的顺序，参数的个数）
*
*/
public class Test {
// jvm执行的方法
public static void main(String[] args) {
// 调用方法
getSum(20, 50);
// getSum(20.5, 20.5);
// getSum("hello", "java");
}
// 两个String类型的参数
private static void getSum(String string, String string2) {
System.out.println("执行了两个String类型的参数");
}
// 求和 两个double类型的参数
private static void getSum(double d, double e) {
System.out.println("执行了两个double类型的参数");
}
// 求和 两个int类型的参数
private static void getSum(int i, int j) {
System.out.println("执行了两个int类型的参数");
}
}
/**
* 参数传递
* 01.基本数据类型 和String 在作为参数传递的时候 传递的是 值！
* 02.引用数据类型在 在作为参数传递的时候 传递的是 地址！
*
*/
public class TestParameters {
public static void main(String[] args) {
/** 传递的String 传递的值
String name = "小黑";
changeName(name);
System.out.println(name);*/
/**
* 传递的String[] 传递的地址
String[] names1 = { "小黑", "小白" };
changeName(names1); // String[] names2=names1
System.out.println(names1[0]);
*/
Student stu1 = new Student();
stu1.name = "小红";
System.out.println("changeName之前=====》" + stu1.name);
changeName(stu1);
System.out.println("changeName之后=====》" + stu1.name);
}
// 传递的是 对象
private static void changeName(Student stu2) {
stu2.name = "小白";
}
// 传递的String[]
private static void changeName(String[] names2) {
names2[0] = "小红";
}
// 传递的String
private static void changeName(String userName) {
userName = "小白";
}
@Test
public void test01() {
String names1[] = { "小黑", "小白" };
String names2[] = names1;
System.out.println(names2[0]);
}
}
============验证用户登录的例子================
public class User { // 用户类
public String userName;
public String pwd;
public User() {
}
// 带参构造
public User(String name, String pwd) {
/**
* 用户传递过来的参数 赋值给了 我们的属性
*/
this.userName = name;
this.pwd = pwd;
}
/**
* 根据前台用户的输入 来判断 用户名以及密码是否正确
*/
public void login(String name, String pwd) {
if (userName.equals(name) && this.pwd.equals(pwd)) {
System.out.println("登录成功");
} else {
System.out.println("用户名或者密码错误！");
}
}
}
public class UserTest {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入您的用户名：");
String userName = scanner.next();
System.out.println("请输入您的密码：");
String password = scanner.next();
/**
* 调用了User类中的带参构造
* 创建对应的的同时 给对象中的userName 和 pwd 赋值
*/
User user = new User("admin", "123456");
/**
* 对象名.方法名（） 调用登录的方法
* 这个方法需要我们传递两个参数
*
*/
user.login(userName, password);
}
}
===========用户购物的方法 方法的重载==================
public class Shopping { // 购物的小例子
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("欢迎光临：请输入您需要的果汁？");
String juice = scanner.next();
System.out.println("请输入您的选择");
System.out.println("1:普通用户 2：老板娘");
int choose = scanner.nextInt();
switch (choose) {
case 1:
System.out.println("请您支付金额：");
int pay = scanner.nextInt();
System.out.println(juicing(juice, pay)); // 普通用户
break;
case 2:
System.out.println(juicing(juice)); // 老板娘
break;
default:
System.out.println("输入循环");
break;
}
}
/**
* 普通用户购买
* @param juice 果汁
* @param pay 支付金额
*/
private static String juicing(String juice, int pay) {
String result = "您得到了一杯" + juice + "汁！ 支付了" + pay + "元";
return result;
}
/**
* 榨汁的方法 老板 喝 不需要钱
* @param juice 用户需要的水果
*/
private static String juicing(String juice) {
String result = "您得到了一杯" + juice + "汁";
return result;
}
}
===========使用Stirng类型的数组 完成 在指定的区间内查询指定的学生============
/**
* 使用带参方法实现学员信息管理
增加学员姓名
在保存了多个学生姓名的数组中，
指定查找区间，查找某个学生姓名并显示是否查找成功
*/
public class StudentTest {
/**
* 声明了 一个成员变量 数组 保存了学生姓名
* 现在这个names数组中所有的值 都是null
*/
String[] names = new String[20];
/**
* 新增姓名到数组中
* @param name 需要新增的姓名
*/
public void addName(String name) {
// 判断 如果元素为null 我们新增
for (int i = 0; i < names.length; i++) {
if (names[i] == null) { // 元素为null
names[i] = name;
break; // 必须要退出
}
}
}
/**
* 遍历数组中所有的元素
*/
private void showNames() {
System.out.println("学生姓名列表如下：");
for (int i = 0; i < names.length; i++) {
if (names[i] != null) { // 元素不为null
System.out.println(names[i]);
}
}
}
/**
* @param find 需要查询的姓名
* @param end 结束的位置
* @param start 开始的位置
*/
private boolean findName(String find, int start, int end) {
boolean flag = false;
for (int i = start - 1; i < end; i++) {
if (names[i].equals(find)) { // 找到了
flag = true;
break;
}
}
return flag;
}
public static void main(String[] args) {
StudentTest test = new StudentTest();
Scanner scanner = new Scanner(System.in);
String name = null;
// 循环 新增 5名学生
for (int i = 0; i < 5; i++) {
System.out.println("请输入学生的姓名：");
// 把用户输入的姓名保存到 数组中
name = scanner.next();
// 调用新增姓名的方法
test.addName(name);
}
// 查询新增之后的数组 元素
test.showNames();
System.out.println("请输入您需要查找的姓名：");
String find = scanner.next();
System.out.println("请输入开始的位置：");
int start = scanner.nextInt();
System.out.println("请输入结束的位置：");
int end = scanner.nextInt();
// 指定区间查询
boolean flag = test.findName(find, start, end);
if (flag) {
System.out.println("找到了");
} else {
System.out.println("人失踪了.......");
}
}
}
====================对象数组==============================
/**
*
*学生类
*/
public class Student {
public String name; // 姓名
public int age; // 年龄
// 带参构造
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
// 无参构造
public Student() {
super();
}
}
public class ArrayTest {
public static void main(String[] args) {
/**
* 数组创建的语法：数据类型 [] 变量名=new 数据类型[大小]；
*
* String类型的数组：只能存放Stirng类型的值
*
*/
String[] names = new String[10];
/**
* Student类型的数组：只能存放Student类型的值
* 对象数组
*/
Student[] students = new Student[5];
/**
* 因为数组中的每个元素都是一个对象
* 对象就得实例化 之后才能使用！
*/
// students[0] = new Student("小黑", 52); 带参实例化
students[0] = new Student();
students[0].name = "小黑";
System.out.println(students[0].name); // null
}
}
==============this的用法===================
public class Student { // 学生类
public String name;
public int age;
/**
* 仅仅是创建了 一个对象
*/
public Student() {
this("小白", 20); // 调用本类的带参构造方法
System.out.println("student的无参构造");
}
/**
* 在创建对象的同时 给对象的属性 赋值
*/
public Student(String name, int age) {
// this(); 调用本类的无参构造方法 必须位于构造方法中的第一行
this.name = name;
this.age = age;
System.out.println("student的带参构造");
}
}
public class StudentTest {
public static void main(String[] args) {
// 实例化Student对象 默认执行Student类中的无参构造
Student stu = new Student();
System.out.println(stu.age);
}
}
/**
*
*学生类
*/
public class Student {
public String name; // 姓名
public int age; // 年龄
// 带参构造
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
// 无参构造
public Student() {
super();
}
}
public class ArrayTest {
public static void main(String[] args) {
/**
* 数组创建的语法：数据类型 [] 变量名=new 数据类型[大小]；
*
* String类型的数组：只能存放Stirng类型的值
*
*/
String[] names = new String[10];
/**
* Student类型的数组：只能存放Student类型的值
* 对象数组
*/
Student[] students = new Student[5];
/**
* 因为数组中的每个元素都是一个对象
* 对象就得实例化 之后才能使用！
*/
// students[0] = new Student("小黑", 52); 带参实例化
students[0] = new Student();
students[0].name = "小黑";
System.out.println(students[0].name); // null
}
}
==============this的用法===================
public class Student { // 学生类
public String name;
public int age;
/**
* 仅仅是创建了 一个对象
*/
public Student() {
this("小白", 20); // 调用本类的带参构造方法
System.out.println("student的无参构造");
}
/**
* 在创建对象的同时 给对象的属性 赋值
*/
public Student(String name, int age) {
// this(); 调用本类的无参构造方法 必须位于构造方法中的第一行
this.name = name;
this.age = age;
System.out.println("student的带参构造");
}
}
public class StudentTest {
public static void main(String[] args) {
// 实例化Student对象 默认执行Student类中的无参构造
Student stu = new Student();
System.out.println(stu.age);
}
}
/**
*
*学生类
*/
public class Student {
public String name; // 姓名
public int age; // 年龄
// 带参构造
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
// 无参构造
public Student() {
super();
}
}
public class ArrayTest {
public static void main(String[] args) {
/**
* 数组创建的语法：数据类型 [] 变量名=new 数据类型[大小]；
*
* String类型的数组：只能存放Stirng类型的值
*
*/
String[] names = new String[10];
/**
* Student类型的数组：只能存放Student类型的值
* 对象数组
*/
Student[] students = new Student[5];
/**
* 因为数组中的每个元素都是一个对象
* 对象就得实例化 之后才能使用！
*/
// students[0] = new Student("小黑", 52); 带参实例化
students[0] = new Student();
students[0].name = "小黑";
System.out.println(students[0].name); // null
}
}
==============this的用法===================
public class Student { // 学生类
public String name;
public int age;
/**
* 仅仅是创建了 一个对象
*/
public Student() {
this("小白", 20); // 调用本类的带参构造方法
System.out.println("student的无参构造");
}
/**
* 在创建对象的同时 给对象的属性 赋值
*/
public Student(String name, int age) {
// this(); 调用本类的无参构造方法 必须位于构造方法中的第一行
this.name = name;
this.age = age;
System.out.println("student的带参构造");
}
}
public class StudentTest {
public static void main(String[] args) {
// 实例化Student对象 默认执行Student类中的无参构造
Student stu = new Student();
System.out.println(stu.age);
}
}
浙公网安备 33010602011771号
