动力节点—day04

• final关键字
  • final修饰的类无法被继承
  • final修饰的方法无法被覆盖
  • final修饰的变量只能赋一次值
  • fianl的引用一旦指向某个对象，则不能重新指向其他对象，但该引用指向对象内部的数据是可以修改的
  • final修饰的实例变量必须手动初始化，不能采用系统默认值
  • final修饰的实例变量一般和static联合使用，称为常量
• 抽象类（半抽象的，可以面向抽象编程，使用多态）
  • abstract和final关键字不能联合使用(抽象类不能用final修饰)
  • 抽象类中还是有构造方法，因为供子类使用
  • 抽象类中可以没有抽象方法，但抽象方法一定在抽象类中
  • 抽象类也属于引用数据类型
  • 抽象类的子类可以是抽象类也可以是非抽象类
  • 抽象方法只有方法的声明，没有方法体
  • 一个非抽象的类继承抽象类，必须将抽象类中的抽象方法覆盖/重写了，这是java语法上强制规定的，必须的，不然编译器就报错了
  • 面向抽象编程，Animal是抽象的，Animal a=new Dog();
  • 抽象类是无法创建对象的，无法实例化的
• 接口（完全抽象的，可以面向接口编程，使用多态）
  • 接口是一种引用数据类型，编译之后也是一个class字节码文件
  • 类和类之间是单继承，接口和接口之间是多继承，类和接口之间是多实现
  • 接口中只包含两部分内容，一部分是常量一部分是抽象方法
  • 接口中所有的元素都是public的
  • 接口中的抽象方法定义时，public abstract修饰符可以省略
  • 接口中常量的修饰符public static final可以省略
  • 类和类之间叫做继承(extends)，类和接口之间叫做实现(implements)
  • 非抽象类实现接口时，必须将接口中的抽象方法全部实现，并且重写之后的方法也是public的，不能省略
  • 继承和实现都存在的话，extends关键字在前，implements关键字在后
• 接口在开发中的作用
  • (补充：多态在开发中的作用：面向抽象编程，不面向具体编程，降低程序的耦合度，提高程序的扩展力)
  • 总结一句话：面向接口编程，可以降低程序的耦合度，提高程序的扩展力，符合OCP开发原则，接口的使用离不开多态机制（接口+多态才能达到降低耦合度）
• 类型和类型之间的关系
  • is a、has a、like a
  • is a
    • cat is a Animal（猫是一个/属于一个动物）
    • 凡是能够满足is a的表示"继承关系"
    • A extends B
  • has a
    • I has a Pen（我有一只笔）
    • 凡是能够满足like a关系的表示"关联关系"
    • 关联关系通常以属性的形式存在
    • A{
    • 　　B b
    • }
  • like a
    • Cooker like a FoodMenu（厨师像一个菜单一样）
    • 凡是能够满足like a关系的表示"实现关系"
    • 实现关系通常是：类实现接口
    • A implements B
• 抽象类和接口有什么区别
  • 抽象类是半抽象的
  • 接口是完全抽象的
    

    ---

  • 抽象类中有构造方法
  • 接口中没有构造方法
    

    ---

  • 接口和接口之间支持多继承
  • 类和类之间只支持单继承
    

    ---

  • 一个类可以同时实现多个接口
  • 一个抽象类只能继承一个类（单继承）
    

    ---

  • 接口中只允许出现常量和抽象方法
• package
  • package是java中的包机制，作用是方便程序的管理，只允许出现在源码的第一行
  • 一般都采用 公司域名倒序+项目名+模块名+功能名（因为公司域名具有全球唯一性）
  • 加上包机制之后，编译  javac java源文件的路径，第一种方法 运行  java 包名.类名(要将字节码放在包目录下)
  • 另一种方法是javac -d . HelloWorld.java
    • javac 负责编译命令
    • -d      带包编译
    • .        代表编译之后生成的东西放在当前目录下
    • HelloWorld.java 被编译的java文件
  • 以后说类名的时候，如果带着包名描述，表示完整类名(java.util.Scanner)，如果没有带包(Scanner)，表示简类名
• import
  • import语句只能出现在package语句之下，class声明之上
  • import可以采用星号，表示该包下所有的类 import  java.util.*或java.util.Scanner
  • java.lang.*,这个包下的类不需要使用import导入
• 访问权限控制符：
  • • public：表示公开的，在任何位置都可以访问
    • protected：在同一个包中的类或者其他包中的子类可以访问
    • 缺省：同一个包中的类
    • private：本类中
  • 属性（4个都能用）
  • 方法（4个都能用）
  • 类（public和默认能用，其他不行）
  • 接口（public和默认能用，其他不行）
• JDK类库的根类：Object
  • 任何一个类都继承Object，就算没有直接继承，也会间接继承
  • 我们去哪找Object类中的常用方法呢？
    • 第一种：去源代码中（API）
    • 第二种：去查阅java类库的帮助文档（API帮助文档）
  • 常用的方法：
    • protected Object clone()        负责对象克隆
    • int hashCode()                       获取对象哈希值
    • boolean equals(Object obj)    判断两个对象是否相等
    • String toString()                      将对象转换成字符串形式
    • protected void finalize()          垃圾回收器负责调用的方法
  • toString方法(一般都需要重写，并且输出引用的时候，会自动调用该引用的toString方法)
    • public String toString() {
      return getClass().getName() + "@" + Integer.toHexString(hashCode());
      }
      源代码的默认实现：类名@对象的内存地址转换为十六进制的形式
  • equals方法(一般都需要重写判断两个对象是否相等)
    • public boolean equals（Object obj）{
               return (this==obj)
      }
    • 判断两个基本数据类型是否相等直接用==就可以
    • 用==判断对象，判断的是两个对象的内存地址是否相等
    • 所以要判断两个对象的是否相等，老祖宗的equals方法不够用，需要子类重写equals
    • 大结论：Java中比较基本数据类型是否相等用==，Java中所有的引用数据类型统一使用equals方法来判断是否相等
    • String类其实重写的toString方法和equals方法，不能用==比较两个字符串是否相等。

    • String aString="123";
      String bString="123";
      String cString=new String("456");
      String dString=new String("456");
      System.out.println(aString==bString);
      System.out.println(cString==dString);
      System.out.println(aString.equals(bString));
      System.out.println(cString.equals(dString));
      true
      false
      true
      true

• • • eclipse中ctrl+f是在java程序中寻找带有关键字的地方
  • finalize()方法
    • 源代码  protected void finalize() throws Throwable { }
    • finalize方法只有一个方法体，里面没有代码
    • 这个方法不需要程序员手动调用，JVM垃圾回收器负责调用这个方法
    • 这个时机称为垃圾销毁时机，如果在垃圾销毁时机想执行一些代码，可以写在该方法中、
  • hashCode()方法
    • 源代码 public native int hashCode();
    • 这个方法不是抽象方法，带有native关键字，底层调用了C++程序
    • 返回的是一个哈希码，实际上就是一个Java对象的内存地址，经过哈希算法，得出一个值，所以执行结果可以等同看作一个Java对象的内存地址

    • Object object=new Object();
      System.out.println(object.hashCode());
      System.out.println(object.toString());
      System.out.println(Integer.toHexString(object.hashCode()));
      366712642
      java.lang.Object@15db9742
      15db9742

• 内部类(使用内部类编写代码，可读性很差，能不用尽量别用)
  • 在一个类的内部定义的类，称为内部类
  • 内部类分为：

    • public class Test06 {
          //静态内部类
          static class Inner1 {
      
          }
          //实例内部类
          class Inner2 {
      
          }
          //局部内部类
          public void dosome() {
              class Inner3 {
      
              }
          }
      }

    • 实例内部类：类似于实例变量

    局部内部类：类似于局部变量(一个方法中的局部内部类，不能被本类的其他方法调用)

    • 匿名内部类：属于局部内部类中的一种，该类没有名字

    • public class Test07 {
          public static void main(String[] args) {
              MyMath math=new MyMath();
              //math.mySum(new ComputeImpl(),100,200);
              math.mySum(new Compute() {//匿名内部类
                  @Override
                  public int sum(int a, int b) {
                      // TODO Auto-generated method stub
                      return a+b;
                  }
              }, 100, 200);
          }
      }
      interface Compute{
          int sum(int a,int b);
      }
      /*class ComputeImpl implements Compute{
          public int sum(int a,int b){
              return a+b;
          }
      }*/
      class MyMath{
          public void mySum(Compute c,int x,int y){
              int retValue=c.sum(x, y);
              System.out.println(x+"+"+y+"="+retValue);
          }
      }

    • 静态内部类：类似于静态变量
  • 内部类的修饰符用四个修饰符中任一都可以