Java程序设计--面向对象基础（六）

---

1、类、对象

对象:是真实存在的具体实例。

类(设计图):是对象共同特征的描述。

定义类

public class 类名{
	1、成员变量(代表属性)
	2、成员方法(代表行为)
	3、构造器
	4、代码块
	5、内部类
}

得到类的对象

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

Car c = new Car();

使用对象

访问属性：对象名.成员变量

访问行为：对象名.方法名(…)

定义类的注意事项

• 成员变量的完整定义格式是∶修饰符数据类型变量名称=初始化值;一般无需指定初始化值，存在默认值。
• 类名首字母建议大写，且有意义，满足“驼峰模式”。
• 一个Java文件中可以定义多个class类，且只能一个类是public修饰，而且public修饰的类名必须成为代码文件名。实际开发中建议还是一个文件定义一个class类。

对象的成员变量的默认规则

数据类型	明细	默认值
基本类型	byte、short、char、int、long	0
基本类型	floa、double	0.0
基本类型	boolean	false
引用类型	类、接口、数组、String	null

---

2、Java对象内存图

多个对象的内存图

1. 对象放在堆内存中
2. 对象变量在内存的栈内存中，其中存储的是对象在堆内存中的地址
3. 成员变量的数据放在对象中，存在于堆内存中

两个变量指向同一个对象内存图

垃圾回收

注意:当堆内存中的类对象或数组对象，没有被任何变量引用（指向）时，就会被判定为内存中的“垃圾”。

Java存在自动垃圾回收器，会定期进行清理。

---

3、构造器

用于初始化一个类的对象，并返回对象的地址。

构造器的定义格式

修饰符 类名(形参列表){
	...
}

构造器的分类

• 无参数构造器（默认存在的)︰初始化的对象时，成员变量的数据均采用默认值。
• 有参数构造器:在初始化对象的时候，同时可以为对象进行赋值。

public class Car {
    String name;
    double price;

    /**
      无参数构造器(默认存在的)
     */
    public Car(){
        System.out.println("无参数构造器被触发执行~~~");
    }

    /**
       有参数构造器
     */
    public Car(String n, double p){
        System.out.println("有参数构造器被触发执行~~~");
        name = n;
        price = p;
    }
}

public class ConstructorDemo {
    public static void main(String[] args) {
        Car c = new Car();
//        c.name = "";
//        c.price
        System.out.println(c.name);//null
        System.out.println(c.price);//0.0

        Car c2 = new Car("奔驰GLC", 39.78);
        System.out.println(c2.name);//奔驰GLC
        System.out.println(c2.price);//39.78
    }
}

注意事项

• 任何类定义出来，默认就自带了无参数构造器，写不写都有。
• 一旦定义了有参数构造器，无参数构造器就没有了，此时就需要自己写一个无参数构造器了。

---

4、this关键字

this关键字可以出现在成员方法、构造器中，代表当前对象的地址。

作用:访问当前对象的成员变量、成员方法。

public class Car {
    String name;
    double price;

    public void goWith(String name){
        System.out.println(this.name +"正在和：" + name +"比赛！");
    }

    /**
      无参数构造器(默认存在的)
     */
    public Car(){
        System.out.println("无参数构造器被触发执行~~~");
    }

    /**
       有参数构造器
     */
    public Car(String name, double price){
        System.out.println("有参数构造器被触发执行~~~");
        System.out.println(this);
        this.name = name;
        this.price = price;
    }
}

public class ThisDemo {
    public static void main(String[] args) {
        Car c = new Car("宝马X3", 37.89);
        System.out.println(c);
        System.out.println(c.name);
        System.out.println(c.price);

        c.goWith("奔驰GLC");
    }
}

---

5、面向对象特征–封装

面向对象的三大特征：封装、继承、多态

封装的实现步骤

• 一般对成员变量使用private(私有)关键字修饰进行隐藏，private修饰后该成员变量就只能在当前类中访问。
• 提供public修饰的公开的getter、setter方法暴露其取值和赋值。

public class Student {
    // private私有的成员变量，只能在本类访问。
   private int age;

   public int getAge(){
       return age;
   }

   public void setAge(int age){
        if(age >= 0 && age <= 200){
            this.age = age;
        }else {
            System.out.println("年龄数据有问题，应该不是人的年龄！");
        }
   }
}

public class Test {
    public static void main(String[] args) {
        Student s = new Student();
        // s.age = -23;
        s.setAge(-23);
        System.out.println(s.getAge());
    }
}

封装的好处小结

1. 加强了程序代码的安全性。
2. 适当的封装可以提升开发效率，同时可以让程序更容易理解与维护。

---

6、标准JavaBean

也可以理解为实体类

标准JavaBean须满足如下要求:

1. 成员变量使用private修饰。
2. 提供每一个成员变量对应的setXxx() / getXxx()。
3. 必须提供一个无参构造器。

public class User {
    private double height;
    private String name;
    private double salary;
    private String address;
    private String phone;

    public User() {
    }

    public User(double height, String name, double salary, String address, String phone) {
        this.height = height;
        this.name = name;
        this.salary = salary;
        this.address = address;
        this.phone = phone;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }
}

public class Test {
    public static void main(String[] args) {
        User user = new User();
        user.setName("二狗");
        user.setHeight(163);
        user.setSalary(50000);
        user.setAddress("中国");
        user.setPhone("13141314520");
//        String name = user.getName();
//        System.out.println(name);
        System.out.println(user.getName());
        System.out.println(user.getHeight());
        System.out.println(user.getSalary());
        System.out.println(user.getAddress());
        System.out.println(user.getPhone());
        }
}

---

8、成员变量、局部变量区别

区别	成员变量	局部变量
类中位置不同	类中，方法外	常见于方法中
初始化值不同	有默认初始化值	没有，使用之前需要完成赋值
内存位置不同	堆内存	栈内存
生命周期不同	随着对象的创建而存在，随着对象的消失而消失	随着方法的调用而存在，随着方法的运行结束而消失
作用域		在所属的大括号中

---