横向关系：

         1.依赖关系：一个对象执行某个方法时需要其他对象参与。

         2.关联关系：比如类与类或者类与接口之间的关系。

         3.组合关系：比如一个超市有很多商品，它们之间就是组合关系。

         4.聚合关系：强制不可分割，比如人和大脑。

纵向关系：

          1.继承关系（子类与父类）

          2.实现关系（类与接口）

一.继承关系（extends）

        对于编程过程中可以将一些类中的相同的属性或者方法写在一个类中，作为父类，其他类可以对父类中非私有的方法以及属性进行调用，子类中也可以写自己特有的属性和方法。这样可以避免代码重复，提高效率，方便后续的代码修改，提高了代码的复用性（即多次使用）

特点：1.子类可以继承父类所有非私有的属性和方法

           2.子类可以通过创建对象调用自己独有的方法

           3.一个子类只能有一个父类，但是一个父类可以有多个子类，

               单继承，但是可以多层继承，比如A继承B，B又继承C

           4.子类不能继承父类的构造函数。

重写：

子类在继承父类的时候，如果方法名相同，就会默认重写。

特点：方法名相同，返回值类型相同，参数列表相同，方法体不同

子类中重写的方法的访问控制修饰符的权限不能低于父类

（访问控制修饰符的权限public>protected>默认不写的>private）

//父类中的方法
public void eat(){
    System.out.println("吃");
}

//子类中重写该方法
public void eat(){
    System.out.println("猫正在吃");
}

重载：

发生在同一个类中，参数列表必须不同（个数，顺序，数据类型），方法名相同

public class Operation {
    public void add(int a, double b){
        System.out.println(a + b);
    }

    //参数的数据类型不同
    public void add(double a,double b){
        System.out.println(a + b);
    }

    //参数的个数不同
    public void add(int a,double b,int c){
        System.out.println(a + b + c);
    }

    //参数的顺序不同
    public void add(double a, int b){
        System.out.println(a + b);
    }
}

二.实现关系 (implements) 

接口(interface)：     

接口是方法的集合，在接口中只有方法的声明，没有方法的实现，具体的实现由接口的实现类来实现 。

特点：

         1.接口中可以定义变量，但要用固定修饰符public static final 进行修饰，所以接口中的变量称为常量,它的值是不可以改变的。

         2.接口中可以定义方法，也是需要修饰符public abstract进行修饰，在jdk1.8以后可以定义static和default修饰的方法

接口不能创建对象

         4.实现类可以实现多个接口

         5.实现类必须实现接口中的所有的方法，否则创建不了对象

public interface Foo {
      int a=10;//接口中变量默认都是public static final的，所以可以直接省略修饰符
      public int b=5;
      static int c=25;
      final int d=36;
      int e;//定义变量必须赋值，这种定义方式是错误的
      public void eat();//定义方法，没有方法体
}

static关键字  （静态的）

static不能修饰类，构造方法，它们只能用public private protected 默认不写的进行修饰

         可以修饰属性和普通方法

public int age;//非静态属性
public static int age;//静态属性

public void get(){
}//非静态方法
public static void get(){
}//静态方法

属性和方法都是需要创建对象之后才能调用的

但是static修饰的属性和方法，可以不用创建对象，直接进行调用（必须在同一个类中）

不同类中调用该方法，可以直接用类名进行调用，也不用创建对象。     

public  class Base {
    public  static void get(){
        System.out.println("好吃");
    }
    public static void main(String[] args) {
          get();//同一个类中，直接调用
    }
}


public class Alpha  {
    public static void main(String[] args) {
         Base.get();//可以不用创建对象，直接用类名进行调用
     }
 }

在同一个类中，静态成员只能直接访问静态成员，要访问非静态成员，必须创建对象

public  class Base {
    public static int a;//静态变量
    public int b;//非静态变量
    public  static void get(){
        System.out.println(a);//可以直接调用
        System.out.println(b);//不能直接调用非静态变量
        System.out.println(this.b);//this以及super都不行，必须创建对象
    }

主函数是程序的入口可以定义在任何类中

public class Base{
public static void main(String[] args){
}
}

静态常量的定义：（常量名全部大写,多个单词使用_进行连接）

public static final 数据类型 常量名 = 值;

final关键字：(最终的)

可以用来修饰:属性，方法，类，但是修饰的类不能被继承，修饰的方法不能被重写，修饰的属性不能被赋值。

游离块：（初始化块）

格式：{方法执行的内容}

可以将构造函数中重复的代码放在游离块中，自动调用，最先执行。

特点：

         1.无论游离块在什么位置，都会在普通方法执行前进行执行

         2.一个对象，只执行一次游离块，创建几个对象，游离块就会执行几次

         3.游离块在创建对象之前就存在，所以会在构造函数之前进行执行

public  class Base {
    public Base(){
        System.out.println("我是一个构造函数");
    }
    {
        System.out.println("我是第1个游离块");
    }

    public void get(){
        System.out.println("我是一个普通的方法");
    }

    {
        System.out.println("我是第2个游离块");
    }
}

//进行测试
 public  class Alpha {
     public static void main(String[] args) {
         Base b1=new Base();
         b1.get();
     }
 }

执行效果：

java 耦合关联 java关联类_java

           

      4.如果两个类存在继承关系，则会先执行父类的游离块，父类的构造函数，然后子类的游离块，子类的构造函数，最后就是调用的方法。

执行效果：

java 耦合关联 java关联类_类_02

      5.静态游离块无论创建几个对象，都只执行一次

格式：static {方法执行的内容}

执行效果：

java 耦合关联 java关联类_java 耦合关联_03