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和包作用域。

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

原文地址:https://www.cnblogs.com/xiaolang8762400/p/7041465.html