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.存款 2.取款 0.退出"); 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()"; } }
/** *狗狗的实体类 */ public class Dog { // 成员变量 public String name; // 姓名 public int health;// 健康值 public int love;// 亲密度 public String strain; // 品种 /** * 无参构造方法 * 访问权限修饰符 类名(){ * } */ public Dog() { System.out.println("Dog类的无参构造函数！"); } /** * 带参构造函数 * 用户在创建对象的时候，给我们传递过来什么值，我们就给数值赋什么值 */ public Dog(String name, String strain, int health, int love) { System.out.println("Dog类的带参构造函数！"); this.name = name; this.strain = strain; this.health = health; this.love = love; } /** * 输出狗狗的信息 */ public void showInfo() { System.out.println("姓名:" + this.name); System.out.println("品种:" + this.strain); System.out.println("健康值:" + this.health); System.out.println("亲密度:" + this.love); } /** * 测试方法 * 测试 我们能不能在实例化对象的同时，给对象的各个属性赋值！ */ public static void main(String[] args) { /** * 会默认执行Dog类中的无参构造函数！ * 如果类中没有对应的无参构造函数，系统默认会创建一个！ * Dog dog = new Dog(); dog.showInfo(); 存在的问题： 如果我们实例化了N个狗狗对象！ 但是每个对象的属性值都是一致的！ 如果我们显式的在类中创建了带参构造，那么系统就不会给我们创建无参构造！ */ Dog dog = new Dog("小狼狗", "拉布拉多", 100, 100); dog.showInfo(); } }
/** *企鹅的实体类 */ public class Penguin { // 成员变量 public String name = ""; // 姓名 public int health = 100;// 健康值 public int love = 50;// 亲密度 public String sex = "Q仔"; // 性别 /** * 输出企鹅的信息 */ public void showInfo() { System.out.println("姓名:" + this.name); System.out.println("性别:" + this.sex); System.out.println("健康值:" + this.health); System.out.println("亲密度:" + this.love); } // shift +alt+ s +o public Penguin(String name, int health, int love, String sex) { this.name = name; this.health = health; this.love = love; this.sex = sex; } // 无参构造 public Penguin() { } }
public class PetTest { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("*************欢迎来到宠物商店*************"); System.out.println("请输入领养宠物的名称："); String name = scanner.next(); System.out.println("请输入领养宠物的类型：(1:狗狗 2:企鹅)"); int choose = scanner.nextInt(); switch (choose) { case 1: // 狗狗 System.out.println("请选择狗狗的品种：（1：藏獒 2:拉布拉多犬）"); choose = scanner.nextInt(); Dog dog = new Dog(); // 创建出一个狗狗的实例 if (choose == 1) { dog.strain = "藏獒"; } else { dog.strain = "拉布拉多犬"; } dog.name = name; // 调用自我介绍的方法 dog.showInfo(); break; case 2: // 企鹅 System.out.println("请选择企鹅的性别：（1：Q仔 2:Q妹）"); choose = scanner.nextInt(); Penguin p = new Penguin(); // 创建出一个企鹅的实例 if (choose == 1) { p.sex = "Q仔"; } else { p.sex = "Q妹"; } p.name = name; // 调用自我介绍的方法 p.showInfo(); break; } } }
/** * 方法重载： * 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); } }