4.10 类间关系 内部类

1.类与类的关系

        继承

        一个类继承一个类

class Animal{

}
class Cat extends Animal{

}

        实现

一个类实现一个接口

interface Animal {
    // 抽象方法,没有方法体
    public abstract void eat();

}

// 猫类
class Cat implements Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

        依赖

完成一件事情需要的中间件，比如人吃饭，需要用筷子或勺子，筷子勺子仅仅时使用的关系。（UML图虚线加箭头）

class Kuaizi{
    public static String use(){
        return "使用筷子";
    } 
}
class People{
    public void eat(Kuaizi kuaizi){
        System.out.print(kuaizi.use + "吃饭");
    }
}    

        关联

相比依赖来说是一种长期的关系，当一个类中有其他类的成员变量，关联可以单向或双向使用（UML图实线加箭头）例如一个人用有一个电脑

class Computer{
}
class People{
    Complter complter;
}

        聚合

是一种有的关系 has-a，各部分可以单独存在（UML图空心菱形 + 实线 + 箭头;箭头指向被聚合的类,也就是说,箭头指向个体/部分）

class Student{
}
class School{
    //
    Student student;
    public School(Student student){ 
          this.student = student; 
    }
}

        组合

是一种is-a的关系，比如人是由四肢等组成，声明周期相同，个体不能离开整体单独存在(UML类图实心菱形 + 实线 + 箭头;箭头指向代表个体/部分的对象,也就是被合成/组合的类的对象)

class Parts{ 
    public Parts createParts(){ 
        System.out.println("创建房间"); 
        return new Parts() ; 
    } 
} 
 
class People{
  private Parts parts ;
  public People(){
   parts = new Parts() ;
  }
  
  public void createPeople(){
   parts.createParts() ;
  }
 }

依赖，关联 : 类之间的关系是在同一层次上； 聚合，组合: 类之间的关系表现为整体和部分

2.内部类

内部类最后生成class文件名为：外部类类名$内部类类名

         成员内部类

类中创建一个类，内部类的等级和成员属性，成员方法一致，使用时需要先创建外部类的对象， 然后在创建内部类的对象

         外部类类名 变量名 = new 外部类类名（）；

         外部类类名.内部类类名 变量名 = 外部类类名.new 内部类类名（）；

class OutClass{//外部类 
    class InClass{//内部类 
    //可以直接使用外部类的私有属性 
    } 
} 

         静态内部类

和成员内部类相视，但是修饰符增加static，类似静态属性，调用时可以不创建外部类的对象， 因为调用静态时直接用类名.静态就行

         OutClass02 outClass02 = new OutClass02();

         若使用内部类对象则创建

         OutClass02.InClass002 inClass002 = new OutClass02.InClass002();

class OutClass{//外部类
      static class InClass{//内部类
      //可以直接使用外部类的私有属性
     }
}

        局部内部类

放在外部类方法中的内部类，外部类的方法可以为静态方法也可以为成员方法 使用时main方法中只能创建外部类的对象，因为局部内部类的作用域只在方法中

        main方法调用

public static void main(String[] args) {
        //静态方法中的内部类，可以不创建对象
        OutClass03 outClass03 = new OutClass03();
        OutClass03.print();
      //成员方法中的内部类，必读创建外部类对象
      OutClass10 outClass10 = new OutClass10();
      outClass10.print();
}

        注：所有创建内部类的对象只能在方法中创建

静态方法中的内部类
class OutClass03 {
     public static void print() {
           class InClass003 {
                 public void ss() {
                       //方法体
                  }
           }
          InClass003 inClass003 = new InClass003();
          inClass003.ss();
      }
}


成员方法中的内部类
class OutClass10 {
     public void print() {
           class InClass003 {
               public void ss() {
                 //方法体
               }
           }
          InClass003 inClass003 = new InClass003();
          inClass003.ss();
      }
}

         匿名内部类（常用）

使用时直接调用，不创建有名称的对象，使用完后直接销毁

public class InClass04 {
     public static void main(String[] args) {
          // 匿名内部类
          test(new OutClass() {
               @Override
               public void login(String username, String password) {
                      System.out.println(username + " : " + password);
                }
          });
      }
      public static void test(OutClass userLogin) {
             userLogin.login("admin", "root");
      }
}
class OutClass {
      void login(String username, String password) {}
}

3.单例设计模式

        构造器私有化

        类内部创建静态类对象

        创建public静态方法用于其他类调用创建本类对象

//测试类
public class Singleton01 {
    public static void main(String[] args) {
        Singleton011.returnSingleton011();
        Singleton012.returnSingleton012();
    }
}
// 单例模式饿汉式
class Singleton011 {
    private Singleton011() {

    }
    private static Singleton011 singleton011 = new Singleton011();
    public static Singleton011 returnSingleton011() {
        return singleton011;
    }
}
// 单例模式懒汉式
class Singleton012 {
    private Singleton012() {

    }
    private static Singleton012 singleton012 =null;
    public static Singleton012 returnSingleton012() {
        if (singleton012==null){
            singleton012 = new Singleton012();
        }
        return singleton012;
    }
}