java类与类之间的继承关系 java的类的继承关系

类与类之间的关系

一、继承关系      继承指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力。在Java中继承关系通过关键字extends明确标识，在设计时一般没有争议性。在UML类图设计中，继承用一条带空心三角箭头的实线表示，从子类指向父类，或者子接口指向父接口。 

二、实现关系      实现指的是一个class类实现interface接口（可以是多个）的功能，实现是类与接口之间最常见的关系。在Java中此类关系通过关键字implements明确标识，在设计时一般没有争议性。在UML类图设计中，实现用一条带空心三角箭头的虚线表示，从类指向实现的接口。 

三、依赖关系      简单的理解，依赖就是一个类A使用到了另一个类B，而这种使用关系是具有偶然性的、临时性的、非常弱的，但是类B的变化会影响到类A。比如某人要过河，需要借用一条船，此时人与船之间的关系就是依赖。表现在代码层面，为类B作为参数被类A在某个method方法中使用。在UML类图设计中，依赖关系用由类A指向类B的带箭头虚线表示。 

四、聚合关系      聚合是关联关系的一种特例，它体现的是整体与部分的关系，即has-a的关系。此时整体与部分之间是可分离的，它们可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享。比如计算机与CPU、公司与员工的关系等，比如一个航母编队包括海空母舰、驱护舰艇、舰载飞机及核动力攻击潜艇等。

显式参数和隐式参数

      显式参数，就是平时见到的在方法名括号中间的参数，就是所谓能看得见的参数。

      隐式参数，是在类的方法中调用了类的实例域。这个被调用的实例域就是隐式参数。在以下的这个类中调用了a.ariseSalary(100)，就用到了隐式参数。比如：

1. public class Abc 
2. { 
3. private double salary; 
4. public Abc(){ 
5.     } 
6. public void ariseSalary(double em){ 
7. double employ = salary * em; 
8.         salary += employ; 
9.     } 
10. }

 

1. Abc a = new Abc(); 
2. a.ariseSalary(100);

在上面的类中，如果调用了这个方法salary是实例域，ariseSalary方法中的salary就是隐式参数。如果在隐式参数的前面加上this，隐式参数就更清晰：

1. public void ariseSalary(double em){ 
2. double employ = this.salary * em; 
3. this.salary += employ; 
4. }

 推荐在隐式参数的前面加上this操作符。this操作符代表的是本类

 

面向对象的特性是：封装,继承,多态  

不要在一个get方法中返回一个可修改对象，这样破坏了封装，应该返回这个对象的clone。

一个方法可以访问它所属的类的所有对象的私有数据。

1. package com.zjf.spring.mybatis.model; 
2. 
       
   
3. public class Person { 
4. private Integer id; 
5. public boolean equals(Person obj) { 
6. return this.id.equals(obj.id); 
7.     } 
8. }

id是obj对象私有属性，但是因为是在Person类里的方法，而obj是Person对象，所以可以使用obj.id。

final域

final实体域

final实体域必须保证在每一个构造器执行之后要被初始化。否则编译错误。也就是要么定义的时候直接赋值，要么在公共构造器代码块初始化它，要么在每个构造器都初始化它。否则编译通不过。

而且构造完之后就不能改变了，这里的不能改变是指对象引用不能变，但是如果这是一个可变对象，它的内容是不能保证不变的。

所以final一般用在基本数据类型，或者不可变类上。用在可变的类上，会造成混乱。

final静态域

和实体域类似，final静态域必须在定义的时候初始化，或者在静态代码块中初始化。

方法参数

java语言总是采用值传递。也就是说，方法得到的是所有参数值的一个拷贝。

这里说的拷贝，是局限在堆栈上的。

对于基本类型很好理解。对于对象的话，我们可以理解。

如：我们要把Person p传递给一个方法，其实我们是这么操作的。

Person p1 = p，然后把p1传递过去。

p1是p在堆栈总的拷贝，但是他们指向同一个堆的位置。

如果，Person是可变对象，这个时候我们执行了p1的方法做了修改，p的内容也会变化。

但是，如果我们，执行p1 = new Person，这个时候不会对p有任何影响。

这就是java所说的：值拷贝，方法不能修改传递给它的参数。

值传递区别与c中的引用传递，如果是引用传递，其实是把p直接传递过去了。

域的初始化

如果没有在构造器中对实体域进行初始化，java会自动初始化。数字为0，布尔为false，对象引用为null。

尽量不要这么做。

默认构造器

仅当类没有提供任何构造器的时候，java会提供一个默认无参构造器。

构造器相互调用

一个构造器调用另外一个通过this方法，而且必须在构造器的第一行代码，而且只能调用一个，只能调用一次。

初始化块

1. package com.zjf; 
2. public class FinalTest { 
3. private final int j ; 
4. //初始化块 
5.    { 
6.       j = 0; 
7.    } 
8. public FinalTest() { 
9. 
       
   
10.    } 
11. }

初始化顺序

1. 所有的域被初始化为默认值（0，false，null）
2. 按照代码出现的顺序，依次执行初始化语句和初始化块。
3. 调用构造器。

关于第二点，举例如下：

1. package com.zjf; 
2. public class FinalTest { 
3. //初始化块 
4.    { 
5.       j = 0; 
6.    } 
7. public FinalTest() { 
8.       System.out.println(j); 
9.    } 
10. private int j = 1; 
11. public static void main(String[] args) { 
12. new FinalTest(); 
13.    } 
14. }

结果为1

如果把初始化块放到下面：

1. package com.zjf; 
2. 
       
   
3. public class FinalTest { 
4. 
       
   
5. public FinalTest() { 
6.       System.out.println(j); 
7.    } 
8. 
       
   
9. private int j = 1; 
10. 
       
   
11. public static void main(String[] args) { 
12. new FinalTest(); 
13.    } 
14. // 初始化块 
15.    { 
16.       j = 0; 
17.    } 
18. }

结果为0。

静态构造器

static 
{ 
 //静态代码 
}

在类（不是对象）初始化的时候调用。

finalize方法

finalize方法会在对象被垃圾回收之前被调用，但是何时被垃圾回收依赖于不同的垃圾回收机制，所以不能保证这个方法什么时候会被执行，所以尽量不要使用这个方法。

public private 包作用域

如果没有public 也没有private 就是包作用域。

类上只能投public和包作用域。

如果方法和属性可以有public ，private和包作用域。

包作用域要求包一模一样，即使是子包也不可以。