Java——面向对象与类

Posted 2020-11-15 xxwang1018

目录

• 一、类和对象
  • 1.1类
  • 1.2对象
  • 1.3类之间的关系
  • 1.4类的使用
• 二、构造函数
  • 初始化
• 三、信息隐藏和this

一、类和对象

面向对象的程序由对象组成，每个对象包含对用户公开的特定功能部分和隐藏的实现部分
规模较小的问题分解为过程的开发方式较理想，面向对象更适用于解决规模较大的问题

1.1类

类是构造对象的模板或蓝图
由类构造对象的过程称为创建类的实例
Java编写的所有代码都位于某个类的内部

封装

• 从形式上看，封装是将数据和行为组合在一个包中，并对对象的使用者隐藏了数据的使用方式
• 对象的数据称为实例域，操纵数据的过程称为方法
• 实现封装的关键在于绝对不能让类中的方法直接地访问其他类的实例域，程序仅通过对象的方法与对象数据进行交互
• 一个类可以全面地改变存储数据的方式，只要仍使用同样的方法操作数据，其他对象就不会知道或介意所发生的变化

继承

• 通过扩展一个类来建立另外一个类的过程称为继承
• 扩展后的新类具有所扩展类的全部属性和方法

1.2对象

对象的三个主要特性

• 对象的行为——可以对对象施加哪些操作
• 对象的状态——当施加那些方法时，对象如何响应
• 对象标识——如何辨别具有相同行为与状态的不同对象

每个对象都保存着描述当前特征的信息，即对象的状态
对象状态的改变必须通过调用方法实现，否则只能说明封装性遭到了破坏

1.3类之间的关系

类之间最常见的关系有依赖，聚合，继承
1、依赖
"use-a"关系，是一种明显的、最常见的关系
如果一个类的方法操纵另一个类的对象，就说一个类依赖于另一个类
应尽可能地将相互依赖的类减至最少，让类之间的耦合度最小
2、聚合
也称“关联”
"has-a"关系
类A的对象包含类B的对象
3、继承
"is-a"关系，表示特殊与一般的关系

1.4类的使用

1、初始化
函数内的局部变量，编译器不会直接给默认值，需要初始化后才能使用。但类的成员变量，编译器会给默认值，可以直接使用
new出对象后，内部属性值默认初始化为：

• short/int/byte：0
• long：0L
• boolean：false
• char：‘u0000‘
• float：0.0f
• double：0.0d

2、赋值
基本变量赋值是值拷贝
对象赋值是直接赋指针，两个对象指向内存中同一个地方

package OO;

/**
 * Java类与对象
 * @version 15:40 2019-09-28
 * @author xxwang1018
 */

class Father {
    private int money = 100;  //私有
    long mobile = 13999999999L;

    public void hello() {
        System.out.println("hello");
    }
}
class Son extends Father {
    public void hi() {
        //子类可以扩展自己的成员方法
        System.out.println("hi~~~~~");
    }

    public void s1()    {
        Son s = new Son();
        System.out.println(s.mobile); //Son没有定义mobile, 而是通过父类继承的
        //System.out.println(s.money); //error 父类的money是私有的，子类无法直接访问
        //子类必须通过父类的方法才能访问父类的私有变量
        s.hello();  //Son没有定义f1, 而是通过父类继承的
        s.hi();     //Son可以自定义自己的成员方法
    }
}

public class Class_Object {
    private int a;
    public void setA(int a) {
        this.a = a;
    }
    public int add(int b) {
        return this.a + b;
    }
    public static void main(String[] a) {
        int b = 5;
        Class_Object obj = new Class_Object();
        obj.setA(10);
        System.out.println(obj.add(b));

        Son son=new Son();
        son.s1();
    }
}

二、构造函数

作用：对象产生时给成员变量赋值

• Java构造函数的名称必须和类名一样，且没有返回值
• 每个Java类都必须有构造函数

• 一个类可以有多个构造函数，只要形参列表不相同即可

• 在new对象的时候，根据实参的不同，自动挑选相应的构造函数。如果实参形参匹配不上，将会报错

• Java具有内存自动回收机制的，当变量退出其生命周期后，JVM会自动回收所分配的对象的内存

初始化

1、默认域初始化
如果构造器中没有显式地给域赋初值（有构造器），就会自动赋默认值：数值为0，布尔值为 false，对象引用为 null
2、有关参数的构造器
如果没有显式定义构造函数，Java编译器自动为该类产生一个空的无形参构造函数，将所有实例域设置为默认值
如果已经有显式的有参构造函数，则编译器无操作
如果类中提供了至少一个构造器，但是没有提供无参数的构造器，则构造对象时如果没有提供参数就会被视为不合法，为预防此事一般手动编写一个无参数构造器，例如

new Employee(){
    //no information
}

3、调用另一个构造器
如果构造器的第一个语句形如 this(…)，这个构造器将调用同一个类的另一个构造器(具体调用哪个要看参数配对)

调用构造器的步骤

1. 所有数据域被初始化为默认值
2. 按照在类声明中出现的次序，依次执行所有域初始化语句和初始化块
3. 如果处理器第一行调用了第二个构造器，则执行第二个构造器主体
4. 执行构造器主体

import java.util.*;
 
/**
 * 对象构造
 * @version 08:09 2019-09-30
 * @auther xxwang1018
 */
 
public class ConstructorTest{
    public static void main(String[] args){
        Employee[] staff = new Employee[3];
        staff[0] = new Employee("harry", 40000);
        staff[0] = new Employee(60000);
        staff[0] = new Employee();
        
        //print out information about all Employee objects
        for(Employee e : staff)
            System.out.println("name="+ e.getName()+ ",id="+ e.getId()+ ",salary="+ e.detSalary());
    }
}
 
class Employee{
    private static int nextId;
    
    private  int id;
    private  String name = ""; //intance field initialization
    private double salary;
    
    //static initialization block
    static{
        Random generator = new Random;
        //set nextId to a random number between 0 and 9999
        nextId = generator.nextInt(10000);
    }
    
    //object initialization block
    {
        id = nextId;
        nextId++;
    }
    
    //three overloaded constructors
    public Employee(String aName, double aSalary){
        name = aName;
        salary = aSalary;
    }
    
    public Employee(double aSalary){
        //calls the Employee(String, double) constructor
        this("Employee #"+ nextId, aSalary);
    }
    
    //the default constructor
    public Employee(){
        //name initialized to "" --see above
        //salary not explicitly set --initialized to 0
        //id initialized in initialization block
    }
    
    public String getName(){
        return name;
    }
    
    public double detSalary(){
        return salary;
    }
    
    public int getId(){
        return id;
    }
}

三、信息隐藏和this

面向对象有一个法则：信息隐藏

• 类的成员属性是私有的 private
• 类的方法是公有的 public，通过方法修改成员属性的值

打个比方：朋友再熟悉，也不会到他抽屉直接拿东西，而是通过他的公开接口来访问、修改东西
this作用

• 指向本类中的成员变量
• 指向本类中的成员方法 this.add(5,3); //调用本类的add方法, this可忽略
• 代替本类的构造函数 this(5); //调用本类的只有一个形参的构造函数

public class ThisTest {
    private int id;
    
    public ThisTest(int id) {
        this.id = id; //指向本类中的成员变量
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
}