四. Java“速学通”之数组和方法与封装

前言

• 课程的第四篇，下一篇开始继承和多态相关的内容，故命名为继承与多态。
• 以防有新读者所以我简述一下第一篇的前言。
• 这个Java急速学习课程适合有一定编程基础的人。它通过实际的代码例子来教Java，减少了理论讲解，使学习过程更直观，帮助你更快地掌握Java的核心技能。课程内容经过优化，力求简洁明了。同时，课程鼓励大家交流心得，提出更好的解决方案，以此来不断改进课程内容。

---

包含的知识

1. 类和对象

• 类的定义：Student、Movie 和 MovieOperator 是三个不同的类，每个类都有自己的属性和方法。
• 对象的创建：通过 new 关键字创建对象，例 Student s1 = new Student();

2. 构造器

• 无参数构造器：用于创建对象并进行基本的初始化
• 有参数构造器：用于在创建对象时传入初始值

3. 封装

• 私有成员变量：使用 private 关键字限制成员变量的访问，例 private int age;
• 公共的 getter 和 setter 方法：提供公共方法来访问和修改私有成员变量，例 public void setAge(int age) {} 和 public int getAge() {}

4. 方法

• 成员方法：类中定义的方法，用于操作对象的数据，例 public void printAllScore() {}
• 静态方法：使用 static 关键字声明的方法，属于类而不是对象，可以通过类名直接调用，例 public static void main(String[] args) {}

5. 数组

• 对象数组：用于存储多个对象的引用，例 Movie[] movies = new Movie[6];

6. 面向对象设计（封装）

• 封装：将数据和操作数据的方法封装在一个类中，提高代码的安全性和可维护性

7. 静态成员

• 静态变量：属于类而不是对象，所有对象共享同一个静态变量，例 private static int count;
• 静态方法：属于类而不是对象，可通过类名直接调用，例 public static void main(String[] args) {}
• 静态代码块：在类加载时执行一次，用于初始化静态变量，例如 static { /* 初始化代码 */ }

8. 实例方法

• 实例方法：属于对象的方法，需要通过对象实例来调用，例 s1.printAllScore();

9. 错误处理

• 简单的错误处理：在 setAge 方法中，通过条件判断来验证输入的合法性，例 if (age > 0 && age < 200) {}

---

具体代码

package basic_0;
 
import java.util.Scanner;
 
public class BasicZc5 {
    public static class Student{//此类封装，把数据和对数据的处理放到同一个类中去
        String name;
        private int age;
        //private 修饰成员变量，只能在本类中直接访问
        private char sex;
        private double chinese;
        private double math;
 
 
        // 构造器：一种特殊方法，不能写返回值类型，名称必须是类名,创建对象时自动被调用
        // ‌作用：创建对象‌,初始化该对象的成员变量,提供默认值,接收参数,可以强制对象初始化操作
        public Student(){
            System.out.println("=====无参数构造器执行了=====");
        }
        public Student(String n){
            System.out.println("=====有参数构造器执行了=====");
        }
 
        public Student(String name, int age, char sex, double chinese, double math){
            this.name = name;
            this.age = age;
            this.sex = sex;
            this.math = math;
            this.chinese = chinese;
        }
 
        public String Name() { return name; }
        // public修饰的get和set方法合理暴露
        // 成员变量的取值和赋值。
        public void setAge(int age) {  // 为年龄赋值
            if (age > 0 && age < 200) { this.age = age; }
            else { System.out.println("您赋值的年龄数据非法！");}}
        public int getAge() {  // 获取年龄
            return age;
        }
 
        public void setChinese(double chinese) {
            this.chinese = chinese;
        }
        public double getChinese() {
            return chinese;
        }
        public double getMath() {
            return math;
        }
        public void setMath(double math) { this.math = math; }
 
        // 成员方法：对数据的操作
        private Student s; // 记住要操作的学生对象。
        public Student(Student s) {
            this.s = s;
        }
        public void printAllScore() {
            System.out.println(s.Name() + "总成绩是：" + (s.getMath() + s.getChinese()));
        }
        public void printAverageScore() {
            System.out.println(s.Name() + "平均成绩是：" + (s.getMath() + s.getChinese()) / 2);
        }
    }
 
    // 定义一个电影类，有编号，电影名称，价格，主演
    public static class Movie {
        private int id; // 编号
        private String name;
        private double price;
        private String actor;
 
        public Movie() {
        }
 
        // 定义一个有参数构造器
        public Movie(int id, String name, double price, String actor) {
            this.id = id;
            this.name = name;
            this.price = price;
            this.actor = actor;
        }
 
        public int getId() {
            return id;
        }
        // this是一个变量，用在方法中，用于拿到当前对象。
        // 哪个对象调用这个方法,this就拿到哪个对象
        public void setId(int id) {
            this.id = id;// this是一个变量，用在方法中，用于拿到当前对象。
            // 哪个对象调用这个方法,this就拿到哪个对象
        }
 
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
 
        public double getPrice() {
            return price;
        }
        public void setPrice(double price) {
            this.price = price;
        }
 
        public String getActor() {
            return actor;
        }
        public void setActor(String actor) {
            this.actor = actor;
        }
    }
    // 电影管理系统
    public static class MovieOperator {
        private Movie[] movies; // 电影对象数组
        public MovieOperator(Movie[] movies) {
            this.movies = movies;
        }
 
        // 打印全部电影信息
        public void printAllMovies() {
            System.out.println("================电影信息如下===============");
            for (int i = 0; i < movies.length; i++) {
                // i = 0 1 2 3 4 5
                Movie m = movies[i];
                System.out.println( m.getId() + "\t" + m.getName() + "\t" + m.getPrice() + "\t" + m.getActor() + "\t" );
            }
        }
 
        // 根据id查询电影
        public void searchMovieById() {
            System.out.println("请输入要查询的电影id：");
            Scanner sc = new Scanner(System.in);
            int id = sc.nextInt();
            // 遍历每个电影对象
            for (int i = 0; i < movies.length; i++) {
                // 拿到当前遍历到的电影对象
                Movie m = movies[i];
                // 判断当前电影对象的id是否是我们正在找的电影id，是则打印出该电影信息并立即结束方法
                if (m.getId() == id) {
                    System.out.println(m.getId() + "\t" + m.getName() + "\t" + m.getPrice() + "\t" + m.getActor() + "\t" );
                    return;
                }
            }
            System.out.println("没有找到该电影");
        }
    }
 
 
    public static void main(String[] args) {
        //封装的设计思想：合理隐藏合理暴露
        Student s1 =new Student();
        s1.setAge(19); // 赋值
        System.out.println(s1.getAge()); // 取值
 
        // 构造器:创建对象时自动调用构造器。
        Student s2 = new Student();// 无参数构造器
        Student s3 = new Student("西门吹雪");// 有参数构造器
 
        System.out.println("--------------------------------");
        //两种方法
        //无参构造器初始化对象
        Student t1 = new Student();
        t1.name = "李二";
        t1.age = 22;
        t1.sex = '男';
        t1.setChinese(92);
        t1.setMath(92);
        System.out.println(t1.name);
        System.out.println(t1.age);
        System.out.println(t1.sex);
 
        //有参构造器初始化对象
        Student t2 = new Student("朱八", 18, '男', 88,88);
        System.out.println(t2.name);
        System.out.println(t2.age);
        System.out.println(t2.sex);
 
        // 操作部分
        Student so = new Student(t1);
        Student so2 = new Student(t2);
        so.printAllScore();
        so.printAverageScore();
        so2.printAllScore();
        so2.printAverageScore();
 
        System.out.println("--------------------------------");
 
        //面向对象
        // 设计电影类Movie，创建电影对象，封装电影数据
        // 封装系统中的全部电影数据
        Movie[] movies = new Movie[6];
        // movies = [null, null, null, null, null, null]
        //            0     1     2     3     4      5
        movies[0] = new Movie(1, "让子弹飞", 9.2, "姜文");
        movies[1] = new Movie(2, "战狼2", 9.2, "吴京");
        movies[2] = new Movie(3, "死侍与金刚狼", 9.2,"瑞安·雷若兹");
        movies[3] = new Movie(4, "逆鳞", 9.2, "沈腾");
        movies[4] = new Movie(5, "美国内战", 9.2, "克斯汀·邓斯特");
        movies[5] = new Movie(6, "小丑2", 9.2, "华金·菲尼克斯");
        // 创建电影操作对象，负责电影数据的业务操作。
        MovieOperator mo = new MovieOperator(movies);
        mo.printAllMovies(); // ALT + ENTER
        mo.searchMovieById();
    }
}
//static修饰符可以用来修饰类的成员方法、类的成员变量，也可以修饰代码块。
//被static修饰的成员属于类本身，不依赖实例，可直接用类名来访问。
//修饰成员变量：变成了类变量。这个类的所有实例共享，所有实例都可以访问这个类变量，但只能通过类名来访问。
//修饰成员方法：变成了类方法。这个类的所有实例共享，所有实例都可用类名调用这个类方法，不需要实例化对象。
//修饰代码块：静态代码块在类被加载时只执行一次。
//修饰内部类：变成了静态内部类。静态内部类不依赖于外部类的实例，可以直接通过外部类名来访问。
//修饰final变量：当static和final同时修饰变量时，就变成了一个常量，值在程序运行中不可改变。
// 1、类名.静态变量（推荐）
// 2、对象名.静态变量（不推荐）
// 3、对象名.实例变量
// 如果这个方法只为做一个功能且不需要直接访问对象的数据，这个方法定义成静态方法
// 如果这个方法是对象的行为，需要访问对象的数据，这个方法定义成实例方法