最全面的Java面向对象讲解（二）_类的成员：属性、方法、构造器

水深无声 2024-04-28 13:13 62阅读 0赞

## 一、类的成员之一：属性 ##

### 1.1 属性的语法格式 ###

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

成员变量也叫实例变量，是指对象的状态。  
成员变量定义在类中，在整个类中都可以被访问。  
成员变量随着对象的建立而建立，存在于对象所在的堆内存中。  
成员变量有默认初始化值。

**说明:**

修饰符:  
常用的权限修饰符有：private、缺省、protected、public  
其他修饰符：static、final (暂不考虑)  
  
数据类型:  
任何基本数据类型(如int、Boolean) 或 任何引用数据类型。  
  
属性名:  
属于标识符，符合命名规则和规范即可。

**举例：**

public class Person {
        private int age;  // 声明private变量 age
        public String name;    // 声明public变量 name
        public String[] hobby; // 声明数组类型的变量
    }

### 1.2 再谈变量的分类 ###

变量的分类：成员变量与局部变量；  
在方法体外，类体内声明的变量称为成员变量。在方法体内部或代码块内部声明的变量称为局部变量。

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_19_color_FFFFFF_t_70_g_se_x_16][]

注意：二者在初始化值方面的异同:  
同：都有生命周期；都需要先声明，后使用；  
异：局部变量除形参外，均需显式初始化。

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16][]

**成员变量vs局部变量的内存位置**

class Person {//人类
        // 1.属性
        String name;// 姓名
        int age = 1;// 年龄
        boolean isMale;// 是否是男性
    
        public void show(String nation) { // nation形参:局部变量
            String color;// color:局部变量
            color = "yellow";
        }
    }
    
    //测试类
    class PersonTest {
        public static void main(String[] args) {
            Person p = new Person();
            p.show("USA");
        }
    }

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 1][]

### 1.3 对象属性的默认初始化赋值 ###

当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。除了基本数据类型之外的变量类型都是引用类型，如上面的Person及前面讲过的数组。

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 2][]

## 二、类的成员之二：方法 ##

什么是方法(method、函数):  
为了解决代码重复编写的问题，可以将需要重复编写的代码提取出来放在一个\{\}(代码块)中，给这段代码起个名字，通过这个名字来调用这段代码就可以实现想要做的事情。提取出来的代码可以组成一个方法。

方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。  
将功能封装为方法的目的是，可以实现代码重用，简化代码  
Java里的方法不能独立存在，所有的方法必须定义在类里。

方法存在的意义:  
1. 提高代码的复用性。  
2. 增强代码的可维护性。

**示例代码：**

public class Person {
        private int age;
    
        public int getAge() { //声明方法getAge()
            return age;
        }
    
        public void setAge(int i) { //声明方法setAge
            age = i; //将参数i的值赋给类的成员变量age
        }
    }

### 2.1 方法的声明格式 ###

成员方法也叫实例方法，是指对象的行为。  
方法也可以称作函数。  
程序的作用体现在方法中，方法是对象功能的基本构件。

修饰符 返回值类型 方法名(参数类型 形参1, 参数类型 形参2, ….)\{  
方法体程序代码  
return 返回值;  
\}

**说明：**

修饰符：
    		public 默认 protected private 等
    
        返回值类型：
    		如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
    		如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字来返回指定类型的变量或常量：“return 数据”。
    		当不确定方法的返回值类型时，可以将返回值类型写成Object（因为Object是java中的根类，可以接收任意类型的返回值）[一般不要这样做]。如果存在分支，必须满足所有分支都有反馈；
    		我们定义方法该不该有返回值？
    			① 题目要求
    			② 凭经验：具体问题具体分析
    
        方法名：
    		属于标识符，命名时遵循标识符命名规则和规范，“见名知意”。
    	
    	参数列表：
    		可以包含零个，一个或多个参数。多个参数时，中间用“,”隔开。
        	参数类型：调用方法时传入的数据的数据类型，参数类型包括基本数据类型和引用数据类型。
    		参数名：调用方法时传入的参数的参数的名字。
    		我们定义方法时，该不该定义形参？
    			① 题目要求
    			② 凭经验：具体问题具体分析
    
        方法体：
    		实现业务功能的代码。
    	
    	return关键字的使用：方法在执行完毕后返还给调用它的程序的数据。
    		使用范围：使用在方法体中
            作用：结束方法，返回返回值。
                ① 结束方法 ② 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。
    			注意点：return关键字后面不可以声明执行语句。
    
        注意事项:
    		方法定义完成之后,在调用方法的时候才会执行方法，不调用的时候不会执行。
    		方法的使用中，可以调用当前类的属性或方法。
    		特殊的：方法A中又调用了方法A:递归方法。
    		方法中，不可以定义方法。

**方法组成三要素**

方法组成的三要素：返回值类型、方法名、参数列表

1、不带参数，不带返回值的方法
            void say(){
                System.out.println("Hello World!!!");
            }
    
        2、带参数不带返回值的方法
            void fun2(int num){
                System.out.println(num);
            }
    
        3、带返回值不带参数的方法
            int fun3(){
                return 100;
            }
    
        4、带参数带返回值的方法。
            int fun4(int num){
                return num;
            }
    
        5、写出计算数组最大值下标的方法。
            int getMax(int[] arr){
                if(arr == null){
                    return -1;
                }
                int maxValue = arr[0];
                int index = 0;
                for(int i = 0; i < arr.length; i++){
                    if(arr[i]>maxValue){
                    maxValue = arr[i];
                    index = i;
                    }
                }
                return index;
            }
    
    
            int getMax(double[] arr){
                if(arr == null){
                    return -1;
                }
                int maxValue = arr[0];
                int index = 0;
                for(int i = 0; i < arr.length; i++){
                    if(arr[i]>maxValue){
                    maxValue = arr[i];
                    index = i;
                    }
                }
                return index;
            }

### 2.2 方法的分类 ###

方法的分类：按照是否有形参及返回值。

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 3][]

### 2.3 方法的调用 ###

方法通过方法名被调用，且只有被调用才会执行。

**方法调用的过程分析**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 4][]

**方法调用的原理和过程**

首先编写一个java类。  
在java类中找到main方法，并且调用main方法。  
在main方法中调用getArea方法。  
让形参接收实参。  
执行getArea方法内部的业务代码。  
方法内部的变量在方法结束时销毁，最后需要把返回值通过return返回方法外。  
结束。

**注意**

方法被调用一次，就会执行一次。  
没有具体返回值的情况，返回值类型用关键字void表示，那么方法体中可以不必使用return语句。如果使用，仅用来结束方法。  
定义方法时，方法的结果应该返回给调用者，交由调用者处理。  
方法中只能调用方法或属性，不可以在方法内部定义方法。

**方法练习题**

1、创建一个Person类，其定义如下：  
(1)创建Person类的对象，设置该对象的name、age和sex属性，调用study方法，输出字符串“studying”，调用showAge()方法显示age值，调用addAge()方法给对象的age属性值增加2岁。  
(2)创建第二个对象，执行上述操作，体会同一个类的不同对象之间的关系。  
(3)通过画图分析内存存储模型。

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_8_color_FFFFFF_t_70_g_se_x_16][]

public class Person {
    
        String name;
        int age;
        /**
         * sex:1 表明是男性
         * sex:0 表明是女性
         */
        int sex;
    
        public void study() {
            System.out.println("studying");
        }
    
        public void showAge() {
            System.out.println("age:" + age);
        }
    
        public int addAge(int i) {
            age += i;
            return age;
        }
    }
    
    public class PersonTest {
        public static void main(String[] args) {
            Person p1 = new Person();
    
            p1.name = "Tom";
            p1.age = 18;
            p1.sex = 1;
    
            p1.study();
            p1.showAge();
    
            int newAge = p1.addAge(2);
            System.out.println(p1.name + "的新年龄为：" + newAge);
            System.out.println(p1.age);//20
    
            System.out.println("----------------------------");
            Person p2 = new Person();
            p2.showAge();//0
            p2.addAge(10);
            p2.showAge();//10
    
            p1.showAge();
    
        }
    }

2、利用面向对象的编程方法，设计类Circle计算圆的面积。

//测试类
    public class CircleTest {
        public static void main(String[] args) {
    
            Circle c1 = new Circle();
    
            c1.radius = 2.1;
    
            //对应方式一：
            //		double area = c1.findArea();
            //		System.out.println(area);
    
            //对应方式二：
            c1.findArea();
    
    
            //错误的调用
            //		double area = c1.findArea(3.4);
            //		System.out.println(area);
    
        }
    }
    
    //圆
    class Circle{
    
        //属性
        double radius;
    
        //求圆的面积
        //方式一：
        //	public double findArea(){
        //		double area = Math.PI * radius * radius;
        //		return area;
        //	}
    
        //方式二：
        public void findArea(){
            double area = Math.PI * radius * radius;
            System.out.println("面积为：" + area);
        }
    
        //错误情况：
        //	public double findArea(double r){
        //		double area = 3.14 * r * r;
        //		return area;
        //	}
        //	
    }

3、对象数组题。  
定义类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 StudentTest {
        public static void main(String[] args) {
    
            //声明Student类型的数组
            Student[] stus = new Student[20];  //String[] arr = new String[10];
    
            for (int i = 0; i < stus.length; i++) {
                //给数组元素赋值
                stus[i] = new Student();
                //给Student对象的属性赋值
                stus[i].number = (i + 1);
                //年级：[1,6]
                stus[i].state = (int) (Math.random() * (6 - 1 + 1) + 1);
                //成绩：[0,100]
                stus[i].score = (int) (Math.random() * (100 - 0 + 1));
            }
    
            //遍历学生数组
            for (int i = 0; i < stus.length; i++) {
                //			System.out.println(stus[i].number + "," + stus[i].state 
                //					+ "," + stus[i].score);
    
                System.out.println(stus[i].info());
            }
    
            System.out.println("********************");
    
            //问题一：打印出3年级(state值为3）的学生信息。
            for (int i = 0; i < stus.length; i++) {
                if (stus[i].state == 3) {
                    System.out.println(stus[i].info());
                }
            }
    
            System.out.println("********************");
    
            //问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
            for (int i = 0; i < stus.length - 1; i++) {
                for (int j = 0; j < stus.length - 1 - i; j++) {
                    if (stus[j].score > stus[j + 1].score) {
                        //如果需要换序，交换的是数组的元素：Student对象！！！
                        Student temp = stus[j];
                        stus[j] = stus[j + 1];
                        stus[j + 1] = temp;
                    }
                }
            }
    
            //遍历学生数组
            for (int i = 0; i < stus.length; i++) {
                System.out.println(stus[i].info());
            }
    
        }
    }
    
    class Student {
        int number;//学号
        int state;//年级
        int score;//成绩
    
        //显示学生信息的方法
        public String info() {
            return "学号：" + number + ",年级：" + state + ",成绩：" + score;
        }
    
    }

**对象数组的内存解析**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 5][]

4、自定义数组工具类  
定义类，定义求最大值、最小值、和、平均分、反转、复制、排序、遍历、查找等方法；

public class ArrayUtil {
    
        // 求数组的最大值
        public int getMax(int[] arr) {
            int maxValue = arr[0];
            for (int i = 1; i < arr.length; i++) {
                if (maxValue < arr[i]) {
                    maxValue = arr[i];
                }
            }
            return maxValue;
        }
    
        // 求数组的最小值
        public int getMin(int[] arr) {
            int minValue = arr[0];
            for (int i = 1; i < arr.length; i++) {
                if (minValue > arr[i]) {
                    minValue = arr[i];
                }
            }
            return minValue;
        }
    
        // 求数组的总和
        public int getSum(int[] arr) {
    
            int sum = 0;
            for (int i = 0; i < arr.length; i++) {
                sum += arr[i];
            }
            return sum;
        }
    
        // 求数组的平均值
        public int getAvg(int[] arr) {
    
            return getSum(arr) / arr.length;
        }
    
        // 反转数组
        public void reverse(int[] arr) {
            for (int i = 0; i < arr.length / 2; i++) {
                int temp = arr[i];
                arr[i] = arr[arr.length - i - 1];
                arr[arr.length - i - 1] = temp;
            }
        }
    
        public void reverse(String[] arr) {
    
        }
    
        // 复制数组
        public int[] copy(int[] arr) {
            int[] arr1 = new int[arr.length];
            for (int i = 0; i < arr1.length; i++) {
                arr1[i] = arr[i];
            }
            return arr1;
        }
    
        // 数组排序
        public void sort(int[] arr) {
            // 冒泡排序
            for (int i = 0; i < arr.length - 1; i++) {
    
                for (int j = 0; j < arr.length - 1 - i; j++) {
    
                    if (arr[j] > arr[j + 1]) {
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
    
                }
    
            }
        }
    
        // 遍历数组
        public void print(int[] arr) {
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + "\t");
            }
            System.out.println();
        }
    
        // 查找指定元素
        public int getIndex(int[] arr, int dest) {
            // 线性查找：
            for (int i = 0; i < arr.length; i++) {
                if (dest == arr[i]) {
                    return i;
                }
            }
    
            return -1;//返回一个负数，表示没有找到
        }
    
    }
    
    public class ArrayUtilTest {
        public static void main(String[] args) {
    
            ArrayUtil util = new ArrayUtil();
            int[] arr = new int[]{32, 34, 32, 5, 3, 54, 654, -98, 0, -53, 5};
            int max = util.getMax(arr);
            System.out.println("最大值为：" + max);
    
            System.out.println("排序前：");
            util.print(arr);
    
            util.sort(arr);
            System.out.println("排序后：");
            util.print(arr);
    
    //		System.out.println("查找：");
    //		int index = util.getIndex(arr, -5);
    //		if(index >= 0){
    //			System.out.println("找到了，索引地址为：" + index);
    //		}else{
    //			System.out.println("未找到");
    //		}
    
    
    //		util.reverse(arr);
        }
    }

### 2.4 方法重载 ###

概述:
            在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数、参数类型、参数顺序不同即可。
    		方法重载的意义是可以减轻开发人员的记忆负担。
    
        特点:
            与方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系。
            参数列表不一样，体现在参数的类型不一样和个数不一样，当个数和类型都一样时，顺序不一样也行。
            在调用时，jvm虚拟机通过参数列表的不同来区分同名方法。
    
    	重载示例：
            //返回两个整数的和
            int add(int x,int y){return x+y;}
            
    		//返回三个整数的和
            int add(int x,int y,int z){return x+y+z;}
            
    		//返回两个小数的和
            double add(double x,double y){return x+y;}
    
    		Arrays类中重载的sort() / binarySearch()
    
    	口诀:
    		判断是不是重载的依据："两同一不同"
    			同一个类、相同方法名
    			参数列表不同：参数个数不同，参数类型不同，参数顺序不同
    
    	在通过对象调用方法时，如何确定某一个指定的方法：	
    		方法名 ---> 参数列表

public class OverLoadTest {
        public static void main(String[] args) {
            OverLoadTest test = new OverLoadTest();
            test.getSum(1, 2);
        }
    
        //如下的4个方法构成了重载
        public void getSum(int i, int j) {
            System.out.println("1");
        }
    
        public void getSum(double d1, double d2) {
            System.out.println("2");
        }
    
        public void getSum(String s, int i) {
            System.out.println("3");
        }
    
        public void getSum(int i, String s) {
            System.out.println("4");
        }
    
        //如下的3个方法不能与上述4个方法构成重载
        //	public int getSum(int i,int j){
        //		return 0;
        //	}
    
        //	public void getSum(int m,int n){
        //		
        //	}
    
        //	private void getSum(int i,int j){
        //		
        //	}
    
    
    }

**代码示例：**

/*
     * 员工类:
     *   成员变量: 员工号、姓名、年龄、岗位、所属部门...
     *   成员方法: 吃饭、工作、睡觉...
     * */
    public class Emp {
        // 成员变量
        int empId;
        String empName;
        String age;
        String job;
        String deptName;
    
        // 成员方法
        void eat() {
            System.out.println(empName + "的吃饭行为");
        }
    
        /*
         * 所有员工都具备工作的行为,但是不能一概而论
         *   同样都是销售工作行为
         *       有的员工工作不用任何帮助都可以完成;
         *       有的员工只需要某个人指导一下即可;
         *       有的员工不仅需要指导,还需要投入金钱请客户吃饭;
         * 方法重载:
         *   在同一个类中,允许存在一个以上的同名方法,只要它们的参数个数、参数类型、参数顺序不同即可。
         *       void work() / work(String name) 参数个数不同
         *       work(String name) / work(double money)  参数类型不同
         *       void work(double money,String name) / work(String name,double money) 参数顺序不同
         * */
        void work() {
            System.out.println("我是老司机,全凭一张嘴,完全搞定客户!");
        }
    
        void work(String name) {
            System.out.println("我是熟练工,但是我需要" + name + "的帮助才可以搞定客户!");
        }
    
        void work(double money) {
            System.out.println("我是熟练工,但是我需要" + money + "元带客户吃喝玩乐才可以搞定!");
        }
    
        void work(double money, String name) {
            System.out.println("我是新手,我需要" + money + "元带客户吃喝玩乐,并且需要" + name + "的帮助才可以搞定!");
        }
    
        void work(String name, double money) {
            System.out.println("我是新手,我需要" + money + "元带客户吃喝玩乐,并且需要" + name + "的帮助才可以搞定!");
        }
    
        void sleep() {
            System.out.println(empName + "的睡觉行为");
        }
    }

使用重载方法，可以为编程带来方便。  
例如，System.out.println()方法就是典型的重载方法，其内部的声明形式如下：  
public void println(byte x)  
public void println(short x)  
public void println(int x)  
public void println(long x)  
public void println(float x)  
public void println(double x)  
public void println(char x)  
public void println(double x)  
public void println()  
……

### 2.5 可变个数的形参 ###

JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。  
JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量  
public static void test(int a ,String\[\] books);  
JDK 5.0开始：采用可变个数形参来定义方法，传入多个同一类型变量  
public static void test(int a ,String…books);  
  
**说明：**  
1. 声明格式：方法名(参数的类型名 ...参数名)  
2. 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个或多个  
3. 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载  
4. 可变参数方法的使用与方法参数部分使用数组是一致的  
5. 方法的参数部分有可变形参，需要放在形参声明的最后  
6. 在一个方法的形参位置，最多只能声明一个可变个数形参

public class MethodArgsTest {
    
        public static void main(String[] args) {
    
            MethodArgsTest test = new MethodArgsTest();
            test.show(12);
            // test.show("hello");
            // test.show("hello","world");
            // test.show();
    
            test.show(new String[]{"AA", "BB", "CC"});
        }
    
        public void show(int i) {
    
        }
    
        public void show(String s) {
            System.out.println("show(String)");
        }
    
        public void show(String... strs) {
            System.out.println("show(String ... strs)");
    
            for (int i = 0; i < strs.length; i++) {
                System.out.println(strs[i]);
            }
        }
        //不能与上一个方法同时存在
        //	public void show(String[] strs){
        //		
        //	}
    
        //The variable argument type String of the method 
        //show must be the last parameter
        //	public void show(String ...strs,int i){
        //		
        //	}
    
    }

### 2.6 方法中的参数传递机制 ###

概述:  
方法，必须由其所在类或对象调用才有意义。当我们要调用一个方法时，我们会把指定的数据，传递给方法中的参数，这样方法中的参数就拥有了这个指定的数据。这种传递方式，被称为参数传递。

参数传递的特点:  
声明方法时，参数列表中的变量，是形式参数，简称形参。  
调用方法时，传给方法的数值，是实际参数，简成实参。

参数传递的分类：  
参数是基本数据类型时，将实参基本数据类型变量的“数据值”传递给形参，简称值传递。  
参数是引用数据类型时，将实参引用数据类型变量的“地址值”传递给形参，简称引用传递。

#### 2.6.1 值传递 ####

public class ValueTransferTest {
        public static void main(String[] args) {
            int a = 10;
            int b = 20;
            System.out.println("a的值:" + a + ",b的值:" + b); // a的值:10,b的值:20
            // 交换两个变量的值
           /* int temp = a;
            a = b;
            b = temp;
            System.out.println("a的值:" + a + ",b的值:" + b);*/
    
            // 交换两个变量的值,是经常要执行的操作,那么我们就可以封装为方法
            ValueTransferTest test = new ValueTransferTest();
            // 参数是基本数据类型时，将实参基本数据类型变量的“数据值”传递给形参，简称值传递。
            test.swap(a, b);
            System.out.println("a的值:" + a + ",b的值:" + b); // a的值:10,b的值:20
        }
    
        void swap(int a, int b) {
            int temp = a;
            a = b;
            b = temp;
        }
    }

#### 2.6.2 引用传递 ####

概述：  
方法中的参数是引用数据类型时，方法中传递的不是具体的数据，而是传递的是引用的地址，因此不需要返回数据。  
参数指向的是堆内存中引用数据类型的对象的地址。把引用数据类型的参数（堆内存中的地址）比喻成一把钥匙，把引用数据类型的对象比喻成一个房子，只要有相同钥匙的人，房间对于这些人是共享的，这些人都可以对这个房间进行操作。

**代码示例：**

public class ArgsTransferTest3 {
        public static void main(String[] args) {
            int a = 10;
            int b = 20;
    
            /*int[] arr = new int[]{a,b};
            System.out.println("a的值:" + arr[0] + ",b的值:" + arr[1]); // a的值:10,b的值:20
            ArgsTransferTest3 test = new ArgsTransferTest3();
            test.swap(arr);
            System.out.println("a的值:" + arr[0] + ",b的值:" + arr[1]); // a的值:20,b的值:10*/
    
            DataSwap dataSwap = new DataSwap();
            dataSwap.a = a;
            dataSwap.b = b;
            System.out.println("a的值:" + dataSwap.a + ",b的值:" + dataSwap.b); // a的值:10,b的值:20
    
            ArgsTransferTest3 test = new ArgsTransferTest3();
            test.swap(dataSwap);
            System.out.println("a的值:" + dataSwap.a + ",b的值:" + dataSwap.b); // a的值:20,b的值:10
        }
    
        void swap(int[] arr) {
            int temp = arr[0];
            arr[0] = arr[1];
            arr[1] = temp;
        }
    
        void swap(DataSwap dataSwap) {
            int temp = dataSwap.a;
            dataSwap.a = dataSwap.b;
            dataSwap.b = temp;
        }
    }
    
    class DataSwap {
        int a;
        int b;
    }

**值传递和引用传递示例代码:**

public class Compare {
        public static void main(String[] args) {
    
            int x = 1000;
            int values[] = {111, 222, 333, 444, 555};
    
            Compare com = new Compare();
            // void test(int num,int arr[])
            // 参数传递: 把x的值传递给num; 把values的值传递给arr
            // x是基本数据类型,那么发生了值传递,相当于把1000复制了一份给num,那么修改num的值不会影响到原数据;
            // values是引用数据类型,那么发生了引用传递,相当于把arr指向了values的地址,那么修改arr会影响到原数据;
            com.test(x, values); // 我们在test()里面对传递进来的值进行了修改
    
            // 在方法里面对传递进来的值进行修改,影不影响原数据?
            System.out.println("\n=========================");
            System.out.println("原数据x:" + x);
            System.out.print("原数据values:");
            for (int n : values) {
                System.out.print(n + "\t");
            }
    
        }
    
        // num是基本数据类型; arr是引用数据类型
        void test(int num, int arr[]) {
            System.out.println("num传递进来的值是:" + num);
            System.out.print("arr传递进来的值是:");
            for (int n : arr) {
                System.out.print(n + "\t");
            }
            // 给num重新赋值
            num = 9999;
    
            // 给arr下标2重新赋值
            arr[2] = 666;
    
            System.out.println("\n方法里面修改过后num的值是:" + num);
            System.out.print("方法里面修改过后arr的值是:");
            for (int n : arr) {
                System.out.print(n + "\t");
            }
        }
    
    }

#### 2.6.3 值传递和引用传递内存解析 ####

**基本数据类型的参数传递**

public static void main(String[] args) {
        int x = 5;
        System.out.println("修改之前x = " + x);// 5
        // x是实参
        change(x);
        System.out.println("修改之后x = " + x);// 5
    }
    
    public static void change(int x) {
        System.out.println("change:修改之前x = " + x);
        x = 3;
        System.out.println("change:修改之后x = " + x);
    }

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_16_color_FFFFFF_t_70_g_se_x_16][]

**引用数据类型的参数传递**

public static void main(String[] args) {
        Person obj = new Person();
        obj.age = 5;
        System.out.println("修改之前age = " + obj.age);// 5
        // x是实参
        change(obj);
        System.out.println("修改之后age = " + obj.age);// 3
    }
    
    public static void change(Person obj) {
        System.out.println("change:修改之前age = " + obj.age);
        obj.age = 3;
        System.out.println("change:修改之后age = " + obj.age);
    }
    
    // 其中Person类定义为：
    class Person{
        int age; 
    }

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 6][]

public static void main(String[] args) {
        Person obj = new Person();
        obj.age = 5;
        System.out.println("修改之前age = " + obj.age);// 5
        // x是实参
        change(obj);
        System.out.println("修改之后age = " + obj.age);// 5
    }
    public static void change(Person obj) {
        obj = new Person();
        System.out.println("change:修改之前age = " + obj.age);
        obj.age = 3;
        System.out.println("change:修改之后age = " + obj.age);
    }
    // 其中Person类定义为：
    class Person{
        int age; 
    }

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 7][]

**方法参数传递练习题：**

1、下面程序的输出结果，并分析内存存储模型。

public class TransferTest1 {
        public void swap(int a, int b) {
            int tmp = a;
            a = b;
            b = tmp;
            System.out.println("swap方法里，a的值是" + a + "；b的值是" + b);
        }
    
        public static void main(String[] args) {
            TransferTest1 test = new TransferTest1();
            int a = 5;
            int b = 10;
            test.swap(a, b);
            System.out.println("交换结束后，变量a的值是" + a + "；变量b的值是" + b);
        }
    }

swap方法里，a的值是10；b的值是5  
交换结束后，变量a的值是5；变量b的值是10

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 8][]

class DataSwap {
        public int a;
        public int b;
    }
    
    public class TransferTest2 {
        public static void swap(DataSwap ds) {
            int temp = ds.a;
            ds.a = ds.b;
            ds.b = temp;
            System.out.println("swap方法里，a Field的值是" + ds.a + ";b Field的值是" + ds.b);
        }
    
        public static void main(String[] args) {
            DataSwap ds = new DataSwap();
            ds.a = 5;
            ds.b = 10;
            swap(ds);
            System.out.println("交换结束后，a Field的值是" + ds.a + ";b Field的值是" + ds.b);
        }
    }

swap方法里，a Field的值是10;b Field的值是5  
交换结束后，a Field的值是10;b Field的值是5

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 9][]

public class TransferTest3 {
        public static void main(String args[]) {
            TransferTest3 test = new TransferTest3();
            test.first();
        }
    
        public void first() {
            int i = 5;
            Value v = new Value();
            v.i = 25;
            second(v, i);
            System.out.println(v.i);
        }
    
        public void second(Value v, int i) {
            i = 0;
            v.i = 20;
            Value val = new Value();
            v = val;
            System.out.println(v.i + " " + i);
        }
    }
    
    class Value {
        int i = 15;
    }

15 0  
20

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 10][]

## 三、类的成员之三：构造器 ##

### 3.1 构造器语法格式 ###

上述我们提到，以下语法用来创建对象  
类名称 对象名称 = new 类名称 () ;  
其实本质是调用了构造函数:  
关键字 new 通常称为创建运算符，用于分配对象内存，并将该内存初始化为缺省值。  
一旦 new 完成分配和初始化内存，它就将调用构造函数来执行对象初始化。  
注：当创建一个类时，只是创建了一种新的数据类型。对象是类的一个实例。创建类不是创建对象。

构造函数是对象的一种特殊的方法（有歧义），主要表现:
            构造函数的方法名与类名相同。
            构造函数没有返回类型。（与声明为void不同）
            构造函数可以不写，系统会默认赋予一个无参构造函数;
            构造函数的主要作用：
    			1、创建对象。
    			2、完成对对象的初始化工作。
    		构造函数不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值
    
    	语法格式：
    		修饰符 类名 (参数列表) {
            	初始化语句；
            } 
    
    	根据参数不同，构造器可以分为如下两类：
    		隐式无参构造器（系统默认提供）
    		显式定义一个或多个构造器（无参、有参）

**示例代码：**

我们人出生的时候，有些人一出生之后再起名字的，但是有些人一旦出生就已经起好名字的。那么我们在 java 里面怎么在对象一旦创建就赋值呢？

public class Person {
    
        String name; // 姓名
        int age; // 年龄
    
        public static void main(String[] args) {
            // 创建了Person类型的p对象，这里的Person()其实就是构造器；而且是系统默认提供的；
            Person p = new Person();
    
            System.out.println("姓名: " + p.name + " 年龄: " + p.age); // name = null, age = 0;
            // 这个小孩刚出生的时候没有姓名和年龄
        }
    }

public class Person {
    
        String name; // 姓名
        int age; // 年龄
    
        // 构造方法
        Person(String pname, int page) {
            name = pname; // 给对象赋予name值
            age = page; // 给对象赋予age值
        }
    
        public static void main(String[] args) {
            // 创建了Person类型的p对象,并且调用构造方法赋予该对象属性值
            Person p = new Person("张三", 1);
            System.out.println("姓名: " + p.name + " 年龄: " + p.age); // name = 张三, age = 1;
            // 这个小孩刚出生的时候已经有了姓名和年龄
        }
    }

**说明：**

Java语言中，每个类都至少有一个构造器。  
默认构造器的修饰符与所属类的修饰符一致。  
一旦显式定义了构造器，则系统不再提供默认构造器。  
一个类可以创建多个重载的构造器。  
父类的构造器不可被子类继承。

public class Person {
    
        String name; // 姓名
        int age; // 年龄
    
        // 全参构造方法
        Person(String pname, int page) {
            name = pname; // 给对象赋予name值
            age = page; // 给对象赋予age值
        }
    
        // 无参构造方法
        Person() {
    
        }
    
        public static void main(String[] args) {
            Person p = new Person("张三", 1); 
            /*
              根据创建对象的实参个数,jvm回去寻找合适的构造方法,
              两个实参所有会调用含有两个参数的构造方法.Person(String name,int age)
             */
            System.out.println("姓名: " + p.name + " 年龄: " + p.age); // name = 张三, age = 1;
        }
    }

**构造函数与普通函数的区别：**

（1）普通函数是用于定义对象应该具备的功能。而构造函数定义的是，对象在调用功能之前，在建立时，应该具备的一些内容。也就是对象的初始化内容。

（2）构造函数是在对象建立时由 jvm 调用, 给对象初始化。普通函数是对象建立后，当对象调用该功能时才会执行。

（3）普通函数可以使用对象多次调用，构造函数就在创建对象时调用。

（4）构造函数的函数名要与类名一样，而普通的函数只要符合标识符的命名规则即可。

（5）构造函数没有返回值类型。

### 3.2 构造器重载 ###

构造器一般用来创建对象的同时初始化对象。如:  
class Person\{  
String name;  
int age;  
public Person(String n , int a)\{ name=n; age=a;\}  
\}

构造器重载使得对象的创建更加灵活，方便创建各种不同的对象。  
构造器重载，参数列表必须不同

**示例代码：**

public class Person {
        private String name;
        private int age;
        private Date birthDate;
    
        public Person(String n, int a, Date d) {
            name = n;
            age = a;
            birthDate = d;
        }
    
        public Person(String n, int a) {
            name = n;
            age = a;
        }
    
        public Person(String n, Date d) {
            name = n;
            birthDate = d;
        }
    
        public Person(String n) {
            name = n;
            age = 30;
        }
    }

### 3.3 总结：属性赋值过程 ###

截止到目前，我们讲到了很多位置都可以对类的属性赋值。现总结这几个位置，并指明赋值的先后顺序。

赋值的位置：  
① 默认初始化  
② 显式初始化  
③ 构造器中初始化  
④ 通过“对象.属性“或“对象.方法”的方式赋值  
  
赋值的先后顺序：  
① - ② - ③ - ④

public class UserTest {
        public static void main(String[] args) {
            User u = new User();
    
            System.out.println(u.age);
    
            User u1 = new User(2);
    
            System.out.println(u1.age);
    
            u1.setAge(3);
            u1.setAge(5);
    
            System.out.println(u1.age);
        }
    }
    
    class User {
        String name;
        int age = 1;
    
        public User() {
    
        }
    
        public User(int a) {
            age = a;
        }
    
        public void setAge(int a) {
            age = a;
        }
    }

## 四、关键字：this ##

this是什么？  
在Java中，this关键字比较难理解，它的作用和其词义很接近。  
它在方法内部使用，即这个方法所属对象的引用；  
它在构造器内部使用，表示该构造器正在初始化的对象。  
  
this 可以调用类的属性、方法和构造器。  
什么时候使用this关键字呢？  
当在方法内需要用到调用该方法的对象时，就用this。  
具体的：我们可以用this来区分属性和局部变量。  
比如：this.name = name;

**使用this，调用属性、方法**

1、在任意方法或构造器内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性。不过，通常我们都习惯省略this。  
2、当形参与成员变量同名时，如果在方法内或构造器内需要使用成员变量，必须添加this来表明该变量是类的成员变量。  
3、使用this访问属性和方法时，如果在本类中未找到，会从父类中查找。

class Person { // 定义Person类
        private String name;
        private int age;
    
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public void getInfo() {
            System.out.println("姓名：" + name);
            this.speak();
        }
    
        public void speak() {
            System.out.println("年龄：" + this.age);
        }
    }

class Person { // 定义Person类
        String name;
    
        Person(String name) {
            this.name = name;
        }
    
        public void getInfo() {
            System.out.println("Person类 --> " + this.name);
        }
    
        public boolean compare(Person p) {
            return this.name == p.name;
        }
    }
    
    // 当前正在操作本方法的对象称为当前对象。
    public class PersonTest {
        public static void main(String args[]) {
            Person per1 = new Person("张三");
            Person per2 = new Person("李四");
            per1.getInfo(); // 当前调用getInfo()方法的对象是per1
            per2.getInfo(); // 当前调用getInfo()方法的对象是per2
            boolean b = per1.compare(per2);
        }
    }

**使用this调用本类的构造器**

4.this可以作为一个类中构造器相互调用的特殊格式。

class Person { // 定义Person类
        private String name;
        private int age;
    
        public Person() { // 无参构造器
            System.out.println("新对象实例化");
        }
    
        public Person(String name) {
            this(); // 调用本类中的无参构造器
            this.name = name;
        }
    
        public Person(String name, int age) {
            this(name); // 调用有一个参数的构造器
            this.age = age;
        }
    
        public String getInfo() {
            return "姓名：" + name + "，年龄：" + age;
        }
    }

思考：  
当我们初始化对象的时候，想要执行某些重复的代码，怎么办？  
1、把重复代码定义在一个成员方法中，调用成员方法；  
2、把重复代码定义在一个构造方法中，调用构造方法；

注意：  
可以在类的构造器中使用"this(形参列表)"的方式，调用本类中重载的其他的构造器！  
明确：构造器中不能通过"this(形参列表)"的方式调用自身构造器。  
如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了"this(形参列表)"。  
"this(形参列表)"必须声明在类的构造器的首行！  
在类的一个构造器中，最多只能声明一个"this(形参列表)"。

JDK示例:  
HashMap、String等

## 五、关键字：package、import ##

### 5.1 关键字—package ###

起因：在我们设计一个程序的时候（尤其是多人合作），会写一些类来实现功能，但是往往会有重名的现象发生，为了解决这个问题，则专门设计了包。（还有其他作用）
    
    	简单理解：不同的城市之间存在相同名字的小区，用城市名则可以区分这些重名小区，城市名就可以理解为上面的包，小区则可以看做是重名的类，通过这个前缀，解决了重名问题。
    
    	为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。其实可以理解为就是文件夹，并且使用了树形目录的存储方式。
    
    	package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。
    
    	它的格式为：
    		package 顶层包名.子包名 ;
    
    	举例：
    		文件系统结构：pack1\pack2\PackageTest.java
    		package pack1.pack2; //指定类PackageTest属于包pack1.pack2
            public class PackageTest{
                public void display(){
                	System.out.println("in method display()");
                }
            }
    
    	包对应于文件系统的目录，package语句中，用 “.” 来指明包(目录)的层次；
    	包通常用小写单词标识。通常使用所在公司域名的倒置：

**包的作用：**

包帮助管理大型软件系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式。  
包可以包含类和子包，划分项目层次，便于管理。  
解决类命名冲突的问题。  
控制访问权限。

**JDK中主要的包介绍**

1. java.lang----包含一些Java语言的核心类，如String、Math、Integer、 System和Thread，提供常用功能  
2. java.net----包含执行与网络相关的操作的类和接口。  
3. java.io ----包含能提供多种输入/输出功能的类。  
4. java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。  
5. java.text----包含了一些java格式化相关的类  
6. java.sql----包含了java进行JDBC数据库编程的相关类/接口  
7. java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。

### 5.2 关键字—import ###

为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)。import语句告诉编译器到哪里去寻找类。
    	语法格式：import 包名.类名;
    
    	应用举例：
    		import pack1.pack2.Test; //import pack1.pack2.*;表示引入pack1.pack2包中的所有结构
            public class PackTest{
                public static void main(String args[]){
                    Test t = new Test(); //Test类在pack1.pack2包中定义
                    t.display();
                }
            }
    
    	注意：
            1. 在源文件中使用import显式的导入指定包下的类或接口。
            2. 声明在包的声明和类的声明之间。
            3. 如果需要导入多个类或接口，那么就并列显式多个import语句即可。
            4. 举例：可以使用java.util.*的方式，一次性导入util包下所有的类或接口。
            5. 如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
            6. 如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。
            7. 如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。
            8. import static组合的使用：调用指定类或接口下的静态的属性或方法

import static java.lang.System.*;
    import static java.lang.Math.*;
    
    public class PackageImportTest {
        public static void main(String[] args) {
    
            out.println("hello");
    
            long num = round(123.434);
        }
    }

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_19_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/b1d21689aa404fdbab702fe76d52be5d.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/10cd256ce3214c8f97a9148bc07c486c.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/6a3ccd10cd1a4f6bb5368f48d17c6fb1.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/5f0e61df90af4573b71dbf66f0feb5f7.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/79ab0a34e378459b872a181a5ef4fffd.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/425935bab4394a188eefc4b5c7ba4e7b.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_8_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/61ed382b60714081b86c26a94e10bd5c.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/2842662e780c4cbbaadf347ccbb7a0c5.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_16_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/edad2f2fb1324e2a8a0965375204db67.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/81116995e9cc4d24abed00860cad8c9d.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/008bc5fc22e646f2a614bf6f442af728.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/da66d7459fa948f3b51a5f4858e0925f.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/cd849a5ed50849c9873c0a7b960753bd.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5oiR5piv5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 10]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/42757f3b99254f11ba20655ac5337907.png