类和对象

1.概念：

　　类：构造对象的模板或蓝图，构建对象的过程称为创建对象的实例。

　　封装：将数据和行为组合在一个包中，并对对象的使用者隐藏数据的实现方式。主要用途是提高类的重用性和可靠性。

　　实例域：对象中的数据。

　　数据域：类中的数据。

　　静态域：使用static修饰的数据。

2.对象：

　　对象的三个主要特性:

　　　　行为:对象的方法；状态:每个对象的实例域值的集合；标识：用于辨别不同的对象；

3.类之间的关系:

　　依赖(uses-a):一个类的方法操作另一个类的对象；（应当适当的降低依赖，减少耦合）

　　聚合(has-a):A类对象包含B类对象(A类数据域中包含B类对象)；

　　继承(is-a)：A类扩展B类；

4.对预定义类的使用：

　　1.使用java.util.date类:（线程不安全）

　　2,使用java.time.localdate类（线程安全）

　　任何对象变量的值都是对存储在另外一个地方的一个对象的引用

5.自定义类：

　 　自定义类一般有自己的实例域和实例方法

　　注意：在一个源文件中，只能有一个公共类，但可以有任意数目的非公有类。

6.关于构造器:

　　1.构造器与类同名

　　2.每个类可以有一个以上的构造器

　　3.构造器可以有一个或者多个参数

　　4.构造器没有返回值

　　5.构造器总是伴随着new操作一起调用

7.显式参数和隐式参数:

　　显式参数:方法参数；

　　隐式参数：本对象的参数（一般this代表隐式参数）；

　　

public Person(int name) {
   this.name = name;    //this.name是隐式参数，name是显式参数
}

8.封装的优点:

　　1.改变内部实现，除了该类的方法外，不会影响其他代码。

　　2.更改器方法可以执行错误检查。

　　注意:不要编写返回引用可变对象的访问器方法（破坏封装），需要返回一个可变对象的引用时，首先对他进行克隆。

　　

class Employee {
    private Date hireDay;

    public Date getHireDay() {
       return hireDay;    //直接返回了可变对象的引用             
      //  return (Date) hireDay.clone();    //正确的做法
    }
}
public class EmployeeDemo {
    public static void main(String[] args) {
        Employee employee = new Employee();
        Date hireDay = employee.getHireDay();
        hireDay.setTime(10000);       //不通过更改器方法直接访问了对象的实例域，因此破坏了封装
    }
}

9.基于类的访问权限:

　　一个方法能够访问所属类的所有对象的私有数据。

　

public class Employee {
    private String name;
    public boolean equals(Employee boss){
        return this.name.equals(boss.name);     //不但访问了该对象的私有数据name而且访问了boss对象的私有数据name
    }
}

10.final实例域

　　构建对象时必须初始化这样的域，也就是说必须确保在构造器执行之后，这个域的值被设置，并且在后面的操作中，不能再对它进行修改。

　　注意：final大部分都应用于修饰基本类型域或者不可变类型的域（如果这个类的所有方法都不用能改变其对象，这种类就是不可变类）。

　　　　　如果修饰可变类，只能限制变量不再指向其他对象，不能限制对该对象的修改。

11.静态域和静态方法

　　静态域:属于类，不属于任何独立的对象。

　　静态常量: 相对于静态变量，静态常量使用的更为频繁，例如Math.PI 。被final修饰的数据域可以设置为公有。

·　　静态方法:不能对对象实施操作的方法

　　　　　　设计成为静态方法的条件:

　　　　　　　　1.一个方法不需要访问对象的状态，所需要的参数都通过显式参数进行提供。

　　　　　　　　2.一个方法只需要访问类的静态域。

12.方法参数（关于Java是值传递还是引用传递）

　　值调用:表示方法接收的是调用者提供的值。

　　引用调用:表示方法接收的是调用者提供的变量地址。

　　注意:Java中只有值传递，没有引用传递，方法得到的是所有参数的值的一个拷贝。

　　Java中参数的使用情况:

　　1.一个方法不能修改一个基本数据类型的参数；

　　2.一个方法可以改变一个对象参数的状态；

·　  3.一个方法不能让对象参数引用一个新的对象；

　　

public class ParamTest {
    public static void main(String[] args) {
        //1.方法不能修改基本数据类型的参数
        double percent = 10;
        System.out.println("Before percent = " + percent);
        tripleValue(percent);
        System.out.println("After percent = "+ percent);
        //2.一个方法可以改变一个对象参数的状态；
        Employee employee = new Employee("Harry",5000);
        System.out.println("Before: salary = " + employee.getSalary());
        tripleSalary(employee);
        System.out.println("After: salary = " +employee.getSalary());
        //3.一个方法不能让对象参数引用一个新的对象；
        Employee a = new Employee("Alice",1000);
        Employee b = new Employee("Bob",2000);
        System.out.println("Before of method: a = " +  a.getName());
        System.out.println("Before of method: b = " + b.getName());
        swap(a,b);
        System.out.println("After of method: a = " +  a.getName());
        System.out.println("After of method: b = " + b.getName());

    }
    public static void tripleValue(double x){
        x = 3 * x;
        System.out.println("end of method: x = " + x);
    }
    public static void tripleSalary(Employee x){
        x.raiseSalary(200);
        System.out.println("end of method: salary = " + x.getSalary());
    }

    public static void swap(Employee x,Employee y){
        Employee temp = x;
        x = y;
        y = temp;
        System.out.println("end of method: x = " +  x.getName());
        System.out.println("end of method: y = " + y.getName());
    }

}
class Employee{
    private String name;
    private double salary;

    public Employee() {
    }

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }


    public double getSalary() {
        return salary;
    }

    public void raiseSalary(double byPercent) {
        double raise = salary*byPercent/100;
        salary += raise;
    }
}

　　运行结果:

　　　　Before percent = 10.0
　　　　end of method: x = 30.0
　　　　After percent = 10.0
　　　　Before: salary = 5000.0
　　　　end of method: salary = 15000.0
　　　　After: salary = 15000.0
　　　　Before of method: a = Alice
　　　　Before of method: b = Bob
　　　　end of method: x = Bob
　　　　end of method: y = Alice
　　　　After of method: a = Alice
　　　　After of method: b = Bob

13.对象的构造:

　　重载:方法名相同，参数列表不同，与返回值类型无关。

　　无参构造器:如果没有给出构造方法会自动提供无参构造，如果自定义了有参构造，则系统不再自动提供无参构造。

　　调用另一个构造器:可以使用this关键字，调用另外的构造器。

14.类的设计技巧：

　　1.一定要保证数据私有；

　　2.一定要对数据进行初始化；

　　3.不要再类中使用过多的基本类型(如果基本类型多可以抽取出一个新的类)；

　　4.不是所有的域都需要独立的域访问器和域更改器；

　　5.将职责过多的类进行分解；

　　6.类名和方法名要能体现他们的职责；

　　7.优先使用不可变的类（可以减少线程安全问题）;