⑦Java面向对象之类及类的成员

Java类及类的成员

---

前言

记录学习Java面向对象编程中类及类的成员：属性、方法、构造器、代码块、内部类。

---

一、类和对象

1.1 类和对象的使用

• 1、创建类，设计类的成员
• 2、创建类的对象=类的实例化=实例化类（每个实例化的类都拥有单独的该类的成员和方法（非static定义的））
• 3、通过“对象.属性”和“对象.方法”调用对象的结构

1.2 对象的内存解析

• 栈存的实例化的对象变量。堆存放的是对象的实例
  
• 匿名对象
  • 创建对象时，没有显示的赋给一个变量即为匿名对象
  • 特征：匿名对象只能调用一次
  • 使用：在实参中使用，传递给形参

二、类的成员之一：属性

2.1 语法格式

• 说明1
  • 常用的权限修符有：private、缺省、protected、public。
  • 其他修饰符：static、final。
• 说明2：数据类型
  • 任何基本数据类型（如int、Boolean）或任何引用数据类型。
• 说明三：属性名
  • 属于标识符，符合命名规则和规范即可。
• 举例

public class Person{
            private int age; //声明private变量 age
            public String name = “Lila”; //声明public变量 name
        }

• 成员变量和局部变量
  

2.2 总结属性赋值的先后顺序

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

三、类的成员之二：方法

3.1 什么是方法？

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

3.2 方法的声明格式

			修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛
                    方法体程序代码
                    return 返回值;
            ｝

• 修饰符：public，缺省，private，protected等。
• 返回值类型：
  • 没有返回值：void。
  • 有返回值：声明出返回值的类型。与方法体中“return 返回值”搭配使用。
• 形参列表：可以包含零个，一个或多个参数。多个参数是，中间用“，”隔开。
• 返回值：方法在执行完毕后返还给调用它的程序的数据。

3.3 使用方法的注意点

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

3.4 方法的重载（避免不必要的方法命名）

• 重载的概念
  • 在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或参数类型不同即可。
• 重载的特点
  • 与返回值类型无关，只看参数列表，且参数列表必须不同。（参数个数或参数类型）调用时，根据方法参数列表的不同来区别。
• 重载示例

	//返回两个整数的和
    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;}

3.5 可变个数的形参

• JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。
  • 声明格式：方法名(参数的类型名 …参数名) 与 方法名(参数的类型名[] 参数名) 相同。
  • 可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个。
  • 可变个数形参的方法与同名的方法之间，彼此构成重载。
  • 可变参数方法的使用与方法参数部分使用数组是一致的。
  • 方法的参数部分有可变形参，需要放在形参声明的最后。
  • 在一个方法的形参位置，最多只能声明一个可变个数形参。

3.6 方法的值传递机制

• 方法，必须由其所在类或对象调用才有意义。若方法含有参数：
  • 形参：方法声明是的参数。
  • 实参：方法调用时实际传给形参的参数值。
• Java的实参值如何传入方法
  Java里方法的参数传递方式只有一种：值传递。即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。
  • 形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参。
  • 形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参。

3.7 递归（recursion）方法（关键：递归体和递归出口）

• 递归方法：一个方法体内调用它自身。
• 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无需循环控制。
• 经典例题：斐波那契数列、汉诺塔。

四、类的成员之三：构造器（构造方法）

4.1 构造器特征

• 它具有与类相同的名称。
• 它不声明返回值类型。（与声明为void不同）
• 它不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值。

4.2 构造器的作用

• 创建对象；
• 对象的初始化；
• 如Order o = new Order(); Person p = new Person(“Peter”,15);

4.3 构造器的分类

• 根据参数不同，构造器可以分为如下两类：
  • 隐式无参构造器（系统默认提供）
  • 显示定义一个或多个构造器（无参、有参）

4.4 构造器的使用注意点

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

五、类的成员之四：代码块

5.1 代码块

• 代码块的作用：用来初始化类、对象。
• 代码块如果有修饰；只能使用static。
• 分类：静态代码块 vs 非静态代码块。

5.2 静态代码块

• 1、可以有输出语句。
• 2、可以对类的属性、类的声明进行初始化操作。
• 3、不可以对非静态对象的属性初始化。即：不可以调用非静态的属性和方法。
• 4、若有多个静态的代码块，那么按照从上到下的顺序依次执行。
• 5、静态代码块的执行要先于非静态代码块。
• 6、静态代码块随着类的加载而加载，且只执行一次。

5.2 非静态代码块

• 1、可以有输出语句。
• 2、可以对类的属性、类的声明进行初始化操作。
• 3、除了调用非静态的代码块，还可以调用静态的变量和方法。
• 4、若有多个非静态的代码块，那么按照从上到下的顺序依次执行。
• 5、每次创建对象的时候，都会执行一次。且先于构造器执行。

六、类的成员之五：内部类

6.1 内部类的定义

• Java中允许将一个类A声明在另一个类B当中，则类A就是内部类，类B称为外部类。

6.2 内部类的分类

• 成员内部类（静态、非静态）
• 局部内部类（方法内、代码块内、构造器内）

6.3 成员内部类

• 一方面：作为外部类的成员：
  • 调用外部类的结构。
  • 可以被static修饰。
  • 可以被4种不同的权限修饰。
• 另一方面：作为一个类：
  • 类内可以定义属性、方法、构造器等。
  • 可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承。
  • 可以被abstract修饰。

总结

以上是对Java面向对象中类及类的成员的学习，有很多很细的知识点，有些会需要用代码才能体现，下面附上学习过程中写的代码，仅供对照知识点学习，并没有什么实际意义。

public class PersonTest {
    public static void main(String[] args) {
        //实例化对象
        Person person = new Person();

        //调用对象的属性
        person.name = "Tom";
        System.out.println(person.name);

        //调用对象的方法
        person.eat();

        //调用可变个数形参方法
        person.show("hello", "world");

        int[] arr = new int[10];
        System.out.println(arr);//地址值

        char[] arr1 = new char[10]; //仅有char[]打印不是地址值
        System.out.println(arr1);//0000000000

        //测试单例模式(饿汉式)
        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();
        System.out.println(bank1==bank2); //true
        //测试单例模式(懒汉式)
        Order order1 = Order.getInstance();
        Order order2 = Order.getInstance();
        System.out.println(order1==order2); //true
    }
}


class Person {
    //属性
    String name;
    int age;
    boolean isMale;

    //方法
    public void eat() {
        System.out.println("人可以吃饭。");
    }

    public void sleep() {
        System.out.println("人可以睡觉。");
    }

    public void show(String ...strs) {
        System.out.println(strs[0] + " " + strs[1]);
    }
}

/**
 * 单例模式(饿汉式)
 */
class Bank {
    //1.私有化构造器
    private Bank() {

    }

    //2.内部创建类的静态对象(在类被加载后，只存在一个静态对象（单例）)
    private static Bank instance = new Bank();

    //3.提供静态的公共的方法返回类的对象
    public static Bank getInstance() {
        return instance;
    }

}

/**
 * 单例模式（懒汉式）
 */
class Order {
    //1.私有化构造器
    private Order() {

    }

    //2.内部创建空的静态对象(在类被加载后，只存在一个静态对象（单例）)
    private static Order instance = null;

    //3.提供静态的公共的方法返回类的对象
    public static Order getInstance() {
        if(instance == null){
            instance = new Order();
        }
        return instance;
    }

}

/**
 * 类的成员之四：代码块
 */
class Girl {
    //1.属性
    String name;
    int age;
    static String description = "I‘m beautiful girl.";

    //3.构造器
    public Girl() {

    }

    public Girl(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //4.代码块
    //static的代码块
    static {
        System.out.println("我是静态代码块。");
    }
    //非静态代码块
    {
        System.out.println("我是非静态代码块。");
    }


    //2.方法
    public void buy() {
        System.out.println("购物！");
    }

    @Override
    public String toString() {
        return "Girl{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}