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'); // ͨ¹ýset()ÊôÐÔ¸³Öµ
        // ͨ¹ýget()È¡Öµ
        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());

    }
}