Java 学习记录 - OOP 入门

面向对象编程

以类的方式组织代码，以对象的方式组织数据。

核心思路：

• 封装
• 多态
• 继承

一、方法

public boolean func (int a, int b){
  return a == b;
}

1.1 修饰符

• public
• private
• protected
• static
• final

1.2 分类

• 静态方法
• 非静态方法

静态方法不能调用非静态方法

二、类和对象

类是一个抽象的，对象是具体的。

2.1 构造器

使用 new 关键字，会调用类的构造器进行初始化。

当一个类未定义任何构造器，会存在一个空构造器。一旦定义了一个有参构造，无参构造需要显示定义

多个构造函数的原理就是方法的重载。

三、封装

高内聚，低耦合

类中的数据应该通过操作接口来完成。

public class test {
  private String name;
  
  public void setName(String name){
    this.name = name;
  }
  
  public String getName(){
    return this.name;
  }
}

四、继承

继承的本质是对一批类的抽象。

Is a

Java 中只有单继承，没有多继承。

如果一个类没有指定父类，系统直接让其继承Object。所以所有类都直接或者间接继承Object类。

父类私有的属性或者方法无法被继承。

4.1 super

可以在子类中调用父类的可访问方法以及构造器

super.func(); // 父类方法
super(); // 父类无参构造器

4.2 注意点

• super 调用父类构造器是，必须在第一行
• super 和 this 不能同时调用构造方法
• 类被final修饰之后不能被继承

4.3 方法重写

• 方法名和参数列表必须相同（不相同叫做重载）。
• 父类 private的方法无法被子类重写。
• 修饰符：范围可以扩大。
• 通过 static、private、final修饰的方法无法被重写

五、多态

父类的引用可以指向子类，方法的调用与引用类型有关。

public class Test{
    public static void main(String[] args) {
      
        B b = new B();// 能调用自己或者继承来自父类的方法。
        b.test(); 

        A a = new B(); // 可以指向子类，但是不能调用子类独有的方法。
        a.test(); 
        a.name;  // Error!! not found
    }
}

class A {
    public void test(){
        System.out.println("A->test");
    }
}

class B extends A {
    public String name;
  
    public void test(){
        System.out.println("B->test");
    }
}

六、类型转换

使用 instanceof 判断对象和类之间的关系；

assert son instanceof Son;
assert son instanceof Father;
assert son instanceof Object;
assert son instanceof Brother; // Error

子类转父类自动转换，会丢失一些子类特殊方法。

父类转子类强制转换，方便方法的调用，减少重复的代码。

public class Test{
    public static void main(String[] args) {
        B b = new B();
        A a = b; // 自动类型转换
        a.say(); // B say something，如果 B 没有重写 say，则输出 A say something。
    }
}

class A {
    public void say(){
        System.out.println("A say something");
    }
    public void test(){
        System.out.println("A->test");
    }
}

class B extends A {
    public String name;
    @Override
    public void test(){
        System.out.println("B->test");
    }
    public void say(){
        System.out.println("B say something");
    }

}

七、Static 关键字

静态变量在内存中只存在一个，能够被多个类的实例化共享。

静态成员变量和方法都可以直接用类.func 进行调用

静态方法只调用静态方法和静态变量。

静态代码块在类加载时就会执行。

// 静态导入包

import static xx.xx.xx.func 

八、抽象类

抽象类是抽象的抽象

public abstract class Action{
  public abstract void func();
}

public class Something extends Action{
  @Override // 必须实现，除非子类也是抽象的
  public abstract void func(){
    
  }
}

// 子类也是抽象时不需要实现父类的抽象方法

抽象类不能被实例化(接口同)

九、接口

面向接口编程

接口中只有方法的申明，就像契约、约束。

public interface UserService{
  (public abstract final) double PI = 3.14;
  (public abstract) void add(int i);
  (public abstract) void plus(int i);
}

public class UserServiceImpl implements UserService{
  // 实现了接口的类必须实现所有方法
  @Override
  public void add(int i);{
    
  }
    @Override
  public void plus(int i);{
    
  }
}

接口可以多继承，不能被实例化

十、内部类

public class Outer{
  
  public class Inner{
    
  }
}

内部类可以获取外部类私有属性和私有方法。

静态内部类可以获取外部类的静态属性和方法

10.1 局部内部类

public class Outer{
  
  public void func(){
     public class Inner{
    
  	}
  }
}

10.2 匿名内部类

new UserService(){
  @Override
  public void add(int i);{
    
  }
  @Override
  public void plus(int i);{
    
  }
}