JavaSe-2022-12-12面向对象

每日一句: 永远给自己一个目标，无论大小，让心能展翅飞翔。

学习内容：Object类、接口、使用接口向下转型、内部类

• Object类

  • Object所有类的顶级父类，java.lang包下（lang包不需要导包,JVM运行时自动调用)

  • 该类定义了类最基础的11个方法其中只抽出重要的三个看看

    • toString():按照指定形式输出对象信息

    • equals():用于比较对象是否相等，比较的本质是对象的属性值

    • hashCode():返回该对象的hash值，相同的对象的哈希值是相同的，建议hashCode和equals一起重写，尽可能保证不同的对象哈希值不同

    • public class TestObject {
          public static void main(String[] args) {
              Aoo aoo = new Aoo();
              System.out.println(aoo);//不重写toStgring,则打印对象的类似地址值
              Aoo a1= new Aoo(1,2);
              Aoo a2= new Aoo(1,2);
              System.out.println(a1==a2);//使用等号比较的是地址值
              System.out.println(a1.equals(a2));//true如果重写Aoo的equals方法
          }
      }
      //如果一个类没有显示继承其他类，则默认继承Object
      class Aoo extends Object{
          int i;
          int j;
          public Aoo(){
      
          }
      
          public Aoo(int i, int j) {
              this.i = i;
              this.j = j;
          }
      
          @Override
          public boolean equals(Object o) {
              if (this == o) return true;
              if (o == null || getClass() != o.getClass()) return false;
              Aoo aoo = (Aoo) o;
              return i == aoo.i && j == aoo.j;
          }
      
          @Override
          public int hashCode() {
              return Objects.hash(i, j);
          }
      
          @Override
          public String toString() {
              return "Aoo{" +
                      "i=" + i +
                      ", j=" + j +
                      '}';
          }
      }
      

• 接口

  • 概念：在Java语言中是一个抽象型，是抽象方法的集合，接口通常以interface来声明，一个类通过继承接口的方式，从而来继承接口的抽象方法。

  • 定义格式

    interface 接口名{
    	public 函数返回值类型 函数名();
    }
    

  • 使用interface关键字,JDK1.8以前含有常量和抽象方法

  • 接口没有构造方法，接口不能被实例化。接口可以被多个使用

  • 使用接口必须实现接口中的方法

  • 接口中修饰的都是抽象方法

  • 一个类必须实现接口抽象方法，除非这个类也是抽象类，

  • 一个接口不能实现另外一个接口，但是可以继承多个其他接口

  • 接口中的定义

    • public interface TestInterface{
      	int MAX_VAlUE = 10; //常量，默认使用 public static final修饰
      	void f(); //抽象方法，默认使用public abstract修饰
      }
      

    • 代码的实现

    • //创建一个接口
      public interface Paper {
          String getSize();
      }
      //实现接口重写方法
      class A4Paper implements Paper{
      	@Override
          public String getSize() {
              return "A4";
          }
      }
      

  • 向下转型的两种方式

    •  public static void main(String[] args) {
      //        一般不使用 最基本使用方法
      //        SafeDoor sd = new SafeDoor();
      //        sd.lock();
      //        sd.unLock();
      //        sd.open();
      //        sd.close();
      //        向上转型
              Door d = new SafeDoor();
              d.close();
              d.open();
              // 1. 使用向下转型，强制转为子类
      //        if(d instanceof SafeDoor){
      //            SafeDoor s = (SafeDoor) d;
      //            s.unLock();
      //            s.lock();
      //        }
      //        2. 将接口看成父类
              Lock l = (Lock) d;
              l.unLock();
              l.lock();
          }
      

• 内部类

  • 内部类中重点是匿名内部类

    • public class TestInnerClass {
      
          public static void main(String[] args) {
              //创建内部类
              Outer outer = new Outer();
              System.out.println(outer.a);
              Outer.Person p = outer.new Person();
              p.f();
              p.print();
      //        静态内部类的创建
              Outer.Coo coo = new Outer.Coo();
              coo.print();
              //局部内部类作用域只能在main方法中访问
              Test t = new Test();
      
              //匿名内部类适用于接口和抽象类，普通类只想创建一个实例
              //且不想让其他类访问这个类
              Ioo ioo = new Ioo() {
                  @Override
                  public void test() {
                      System.out.println("test");
                  }
              };
              ioo.test();
              //练习：使用匿名内部类创建woo的一个实例，并调用其方法
              Woo w  = new Woo() {
                  @Override
                  public boolean equals(Object obj) {
                      return super.equals(obj);
                  }
              };
              w.show();
      
          }
      }
      abstract  class Woo{
          public void show(){
              System.out.println("跑");
          }
      }
      
      interface Ioo{
          void test();
      }
      class Outer{ //外部类
          public int a;
          public class Person{
              int id;
              String name;
              int age;
              public void f(){
                  System.out.println("Person");
              }
              public void print(){
                  System.out.println(a);//内部类可以访问外部类的资源
              }
          }
          static int b;
          public static class Coo{
              int c;
              static int d;
              public void print(){
      //            System.out.println(a); //静态内部类中不能访问非静态属性
                  System.out.println(b);
              }
          }
      
      }
      

• gitee代码仓库地址:https://gitee.com/Zhengsenbing/java-se-basic