21.8.9-Java中类、包、对象、属性、方法

1.创建类和对象

①.类的组成

[1]属性（对应程序中的数据）

通过程序中的各种数据类型，来描述一个类的『特征』

[2]行为（对应程序中的操作）

通过程序中的方法（也就是面向过程视角中的函数），来执行这个类的对象能够做的『动作』

②.声明一个空类

③.声明一个完整类(有属性和方法)

public class Person {

    //属性：若没有初始化，系统自动初始化为0
    int weight;

    //方法:public代表公共方法，任何地方都可被调用，int i是形式参数
    public void add(int i){
        weight+=i;
    }
    
    //不写修饰符默认是缺省的，类内和同包下类可以访问
    void say(){
        System.out.println("weight = " + weight);
    }

}

④.对上面的Person类测试调用

public class PersonTest {
    public static void main(String[] args) {
        //1.创建Person类型的变量，使用new关键字创建Person类的对象
        Person person = new Person();

        //2.调用Person对象的add()方法,传入5作为实参
        person.add(5);

        //3.调用Person对象的say()方法：让这个人说说他的体重
        person.say();

        //4.直接修改weight属性
        //在类之外的其他地方是否可以操作类的属性，取决于属性的修饰符
        person.weight = 20;
        person.say();
    }
}

2.包

①.包的作用

包最重要的作用：区分同名的类,将不同的类放在不同包下。

JDK自带一个类，如果我们再创建相同名字的类，就会冲突。如果没有包名，我们就没法区分两个类。

3.类中的属性

①声明属性的语法格式

修饰符 数据类型 属性名;

或

修饰符 数据类型 属性名 = 初始化值;

②初始化值

③权限修饰符

权限修饰符不仅对类的属性有要求，对类中的方法的要求是完全一样的：

修饰符名称	含义	本类	同包其他类	子类	同工程其他类
private	私有	√	×	×	×
default	缺省	√	√	×	×
protected	受保护	√	√	√	×
public	公共	√	√	√	√

④属性名

属性也叫成员变量，所以属性名作为标识符适用变量的标识符规则和规范。

4.对象的内存分析

①类的实例化

Cat c = new Cat();

看见使用了new关键词，就表示在堆内存中一定开辟了新的空间，一定创建了新的对象。

②类的多个实例化

Cat c1 = new Cat();
Cat c2 = new Cat();

c1与c2对象互不干扰，内存空间不相同

③类的一个对象初始化另一个对象

Cat c1 = new Cat();
Cat c2 = c1;

c1与c2对象共享相同的内存地址存储数据，如果c1的数据发生变化，也会影响到c2

④变量置空

cat04 = null;

变量置空之后，变量就不指向内存地址，而是NULL，内存地址的数据就会被回收。

5、方法

①参数和返回值

方法的参数和返回值都不是必须有的，根据需要设置。

• 方法的参数：我们命令方法替我们干活的时候，有时需要给方法提供一些数据。
  • 形式参数：声明方法时指定的参数，用来说明这个方法可以接受哪些参数（简称形参）
  • 实际参数：调用方法时实际传入的参数，用于方法执行过程中实际的运算（简称实参）
• 方法的返回值：方法执行完成后，给方法的调用者返回的结果数据。

②声明方法的代码

// 声明一个方法：求两个整数的和
// int a,int b声明方法的参数：形式参数
// public int：表示方法的访问权限是public，返回值是int类型
// 方法名：add
public int add(int a, int b) {

    // 计算a + b的和
    int addResult = a + b;

    // 使用return关键字将a + b的和返回给方法的调用者
    return addResult;
}

③调用方法的代码

// 1.要调用一个方法，需要先创建方法所在类的对象
Calculator calculator = new Calculator();

// 2.通过对象调用方法
// 这里传入给方法的5、11，我们叫做实际参数
int addResult = calculator.add(5, 11);

④方法相关规则

• 方法调用一次就会执行一次
• 方法必须写在类中，不能独立存在。
• 方法如果没有返回值，方法体内可以没有return；如果写了return，那么表示方法结束。
• 方法声明的返回值类型必须和实际返回的数据类型一致。
• 方法内部不能再声明方法。

练习作业：

1.创建一个Person类

(1)创建Person类的对象,设置该对象的name、age和sex属性,调用study方法,输出字符串“studying”，调用showAge()方法显示age值,调用addAge()方法给对象的age属性值增加2岁。
(2)创建第二个对象,执行上述操作,体会同一个类的不同对象之间的关系。

public class Person {
    String name;
    int age;
    int sex;

    public void study(){
        System.out.println("studying");
    }
    public void showAge(){
        System.out.println("age = " + age);
    }
    public void addAge(int i){
        age+=i;
    }
}
public class PersonTest {
    public static void main(String[] args) {
        Person person = new Person();
        person.study();
        person.addAge(5);
        person.showAge();
    }
}

2.Circle计算圆的面积。

public class Circle{
    private double r;

    void input(double rx){
        r=rx;
    }
    void show(){
        System.out.println(String.format("半径为%.2f的圆，面积为%.2f", r,3.14*r*r));
    }
}
public class CircleTest {
    public static void main(String[] args) {
        Circle c = new Circle();
        c.input(5);
        c.show();
    }
}

3.矩阵

3.1编写程序，声明一个method方法，在方法中打印一个10x8的矩形,在main方法中调用该方法。
3.2修改上一个程序，在method方法中，除打印一个10x8的矩形外，再计算该矩形的面积，并将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。
3.3修改上一个程序，在method方法提供m和n两个参数，方法中打印一个m*n的矩形，并计算该矩形的面积，将其作为方法返回值。在main方法中调用该方法,接收返回的面积值并打印。

public class Method {
    private double chang;
    private double kuan;

    public void start(double c,double k){
        chang=c;
        kuan=k;
    }
    public double show(){
        for (int i = 0; i < chang; i++) {
            for (int j = 0; j < kuan; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
        return chang*kuan;
    }
}
public class MethodTest {
    public static void main(String[] args) {
        Method m = new Method();
        double s;
        m.start(5,6);
        s = m.show();
        System.out.println("s = " + s);
    }
}

4.定义类Student

对象数组题目:定义类Student，包含三个属性:学号number(int)，年级state(int)，成绩score(int)。创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。

问题一:打印出3年级(state值为3）的学生信息。
问题二:使用冒泡排序按学生成绩排序，并遍历所有学生信息
提示:
1)生成随机数:Math.random()，返回值类型double;
2)四舍五入取整: Math.round(double d)，返回值类型long。

public class Student {
    int number;
    int state;
    int score;

    // 用于每次打印Student对象的信息，代码复用，不必每次想打印时都再写一遍
    public void showMyInfo() {
        System.out.println("number=" + number + "\tstate=" + state + "\tscore=" + score);
    }
}
public class StudentTest {
    public static void main(String[] args) {
        //创建Student数组
        Student st[] = new Student[20];

        // 循环20次创建20个Student对象并存入Student数组
        for (int i = 0; i < 20; i++) {
            //创建Student对象
            Student student = new Student();
            //给Student对象设置number属性
            student.number = i + 1;
            //给Student对象设置state属性
            student.state = (int) (Math.random() * 10) + 1;
            //给Student对象设置score属性
            student.score = (int) (Math.random() * 100);
            //将Student对象存入数组
            st[i] = student;
            //判断当前Student对象的state属性是否为3
            if (student.state==3)
                student.show();
        }
        System.out.println("==========================================");
        // 对数组中的元素进行冒泡排序
        // 外层循环：控制『冒泡』次数
        for (int i = 0; i < 20; i++) {
            // 内层循环：负责执行『冒泡』
            // 每冒泡一次就是把当前范围最大的元素移动到最后
            // 减 i 是因为已经排序好的元素不用动
            // 减 1 是因为避免j+1找下一个元素时数组下标越界
            for (int j = 0; j < (20 - i - 1) ; j++) {
                // 将『当前学生的分数』和『下一个学生的分数』进行比较
                if (st[j].score > st[j+1].score) {
                    // 交换：需要借助中间变量
                    Student swap = st[j];
                    st[j] = st[j+1];
                    st[j+1] = swap;
                }
            }
        }
        //遍历Student数组
        for (int i = 0; i < 20; i++) {
            Student s = st[i];
            s.show();
        }
    }
}