Java学习笔记（七）：面向对象② —— 类与对象的结构

  
  
  

Java 类及类的成员

  

现实世界的生物体，大到鲸鱼，小到蚂蚁，都是由最基本的细胞构成的。同理，Java 代码世界是由诸多个不同功能的类构成的。

现实生物世界中的细胞又是由什么构成的呢？细胞核、细胞质、… 那么，Java 中用类 class 来描述事物也是如此。常见的类的成员有：

• 属性：对应类中的成员变量
• 方法：对应类中的成员方法

  

面向对象的两个要素：

类：对一类事物的描述，是抽象的、概念上的定义
对象：是实际存在的该类事物的每个个体，因而也称为实例（instance）

面向对象程序设计的重点是类的设计
设计类，就是设计类的成员 —— 属性、方法

• 属性 = 成员变量 = field = 域、字段
• 方法 = 成员变量 = 函数(其他语言才有) = method
• 创建类 = 类的实例化 = 实例化类

  
  
  

类与对象的创建及使用

  

创建类的格式：

修饰符 class 类名 {
  属性声明;
  方法声明;
}

PS：类的修饰符只能是：public 或 缺省(default)

  
创建对象的格式：

使用new关键字创建对象

类名 对象名 = new 类名()；

  

类和对象的使用（面向对象思想落地的实现）：

1. 创建类，设计类的成员
2. 创建类的对象
3. 通过对象.属性或对象.方法调用对象的结构
     

举个例子，先创建一个类：

// 创建类
class Person{

    // 属性
    String name;
    int age = 1;
    boolean isMale;

    // 方法
    public void eat(){
        System.out.println("猛吃一大碗");
    }

    public void sleep(){
        System.out.println("睡得像🐖一样");
    }

    public void say(String language){
        System.out.println("人能说话，使用的是:" + language);
    }


}

  
再创建个对象，并调用对象的属性和方法：

public class PersonTest {
    public static void main(String[] args) {

        // 创建Person类的对象
        Person p1 = new Person();

        //调用对象的结构: 属性，方法
        //调用属性: 对象.属性
        p1.name = "Tom";
        p1.isMale = true;
        System.out.println(p1.name);
        //调用方法: 对象.方法
        p1.eat();
        p1.say("中文");


        // 再创建一个Person类的对象
        Person p2 = new Person();
        System.out.println(p2.name);   // 通过同一个类创建的多个对象，都独立的拥有一套类的属性

		// 把p1对象保存的对象地址值赋给了p3, 导致p1和p3指向了堆空间中的同一个对象实体。
        Person p3 = p1; 
        
        System.out.println(p3.name);    // 调用p3，实际上就是调用的p1
        p3.name = "Bob";    // 修改p3，实际上修改的也是p1
        System.out.println(p1.name);    // p1和p3始终相等
        System.out.println(p3.name);

    }

}

  
  
  

类的成员之一：属性

  

属性（成员变量）  vs  局部变量
 

相同点：

1. 定义变量的格式：数据类型 变量名 = 变量值
2. 先声明，后使用
3. 变量都有其对应的作用域

 
不同点：

1. 在类中声明的位置不同
   属性：直接定义在类的一对{ }内
   局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
2. 关于权限修饰符的不同
   属性：可以在声明属性时，指明其权限，使用权限修饰符。
      常用的权限修饰符：private、缺省、protected、public ——> 封装性
   局部变量：不可以使用权限修饰符。
3. 默认初始化值的情况：
   属性：类的属性，根据其类型，都有默认初始化值。
      整形（byte、short、int、long）：0
      浮点型（float、double）：0.0
      字符型（char）：0 （或’\u0000’）
      布尔型（boolean）：false
      
      引用数据类型（类、数组、接口）：null
      
   局部变量：没有默认初始化值。
      意味着，我们在调用局部变量之前，一定要显示赋值。
      特别的，形参在调用时，我们赋值即可。
4. 在内存中加载的位置：
   属性：加载到堆空间中（非static）
   局部变量：加载到栈空间中

  
  
  

类的成员之二：方法

  
方法：描述类应该具有的功能。
  
方法的分类：
按照是否有形参及返回值 划分
  

	无返回值	有返回值
无形参	修饰符 void 方法名 ( ) {}	修饰符 返回值类型 方法名 ( ) {}
有形参	修饰符 void 方法名 (形参列表) {}	修饰符 返回值类型 方法名 (形参列表) {}

  
方法的声明：

权限修饰符 返回值类型 方法名 (形参列表) {
    方法体
}

 
 
注意：

1. Java规定的4种权限修饰符：private、缺省、protected、public
2. 返回值类型：有返回值 vs 没有返回值
   如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字来返回指定类型的变量或常量：return 数据
   如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要使用return。但是，如果使用的话，只能return;表示结束此方法的意思。
3. 方法名：属于标识符，遵循标识符的规则和规范，见名知意
4. 形参列表：方法名可以声明0个、1个，或多个形参。
   格式：数据类型1 形参1，数据类型2 形参2，…
5. 方法体：方法功能的体现。

 
 
return 关键字的使用：

1. 使用范围：使用在方法体中
2. 作用： ① 结束方法
       ②对于有返回值类型的方法，使用return 数据方法返回所要的数据。
3. 注意点：return关键字后面不可以再写执行语句（return就退出方法了，下一行不管写什么都不会执行）

 
 
方法的使用中，可以调用当前类的属性或方法：

    特殊的：方法A中又调用了方法A：递归方法。

方法中，不可以定义方法！！！

  
  
  

方法的重载(overload)

  

定义：

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

  两同一不同：同一个类（包括父类和子类）、相同方法名
        参数列表不同（包括：参数个数不同，参数类型不同）
  

判断是否重载：

与方法的返回值类型、权限修饰符、形参变量名、方法体都无关。只需看两同一不同！！！

  
在通过对象调用方法时，如何确定某一个指定的方法：

1. 方法名
2. 参数列表

  
举个例子：

public class OverLodeTest {
    public static void main(String[] args) {

        OverLodeTest a = new OverLodeTest();
        a.get();
        // 把括号里的一次从无，到5，到加个.1变为5.1，到加俩引号；下面方法依次发亮，证明被选中了

    }



    public void get(){
        System.out.println("1");
    }

    //    public int get(){   // 报错: 'get()' is already defined in 'question.oopUp.OverLodeTest'
//        System.out.println("1");  // 所以说，改返回值类型没用，重载跟返回值类型和修饰符无关
//        return 1;
//    }

    public void get(int a){
        System.out.println("2");
    }

    public void get(double a){
        System.out.println("3");
    }

    public void get(String a){
        System.out.println("1");
    }

}

  
  
  

可变个数形参

  

JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。

JDK5.0以前，想要传入多个同一类型变量，采用数组形参来定义方法
JDK5.0以后，想要传入多个同一类型变量，采用可变个数形参来定义方法

如果数组形参和可变个数形参里面数据一样的话，那么参数列表是相同的！！！
这俩本身就是同一结构，只是写法不同！！！

具体使用：

1. 可变个数形参的格式：数据类型 … 变量名
2. 当调用可变个数形参的方法时，传入的参数的个数可以是：0个，1个，2个…
3. 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。
4. 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。即二者不可共存。
5. 可变个数形参在方法中的形参中,必须声明在末尾。
6. 可变个数形参在方法中的形参中，最多只能声明一个可变形参。

  
  
  

值传递机制

  

Java中参数传递机制：
值传递
  

规则：

• 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
• 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。

  
推广：

• 如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
• 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

  
两个概念：

• 形参：方法定义时，声明在小括号内的参数
• 实参：方法调用时，实际传递给形参的数据

  
举例：

针对基本数据类型：
如果参数是基本数据类型，此时实参赋值给形参的是实参真是存储的数据值。

public class ValueTransferTest1 {
    public static void main(String[] args) {

        int m = 10;
        int n = 20;

        System.out.println("m = " + m + ", n = " + n);

        ValueTransferTest1 test = new ValueTransferTest1();
        //交换两个变量的值的操作
        test.swap(m, n);

        System.out.println("m = " + m + ", n = " + n);

    }

    public void swap(int m,int n){
        int temp = m;
        m = n;
        n = temp;
    }
}

swap() 并没有把m，n的值交换
  
  
针对引用数据类型：
如果参数是引用数据类型，此时实参赋值给形参的是实参存储数据的地址值。

public class ValueTransferTest2 {
    public static void main(String[] args) {
        Data data = new Data();

        data.m = 10;
        data.n = 20;

        System.out.println("m = " + data.m + ", n = " + data.n);
        
        
        ValueTransferTest2 test = new ValueTransferTest2();
        //交换m和n的值
        test.swap(data);

        System.out.println("m = " + data.m + ", n = " + data.n);

    }

    public void swap(Data data){
        int temp = data.m;
        data.m = data.n;
        data.n = temp;
    }
}
class Data{
    int m;
    int n;
}

m，n的值交换了