动力节点—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);

    }

}

静态内部类：类似于静态变量

内部类的修饰符用四个修饰符中任一都可以

巴特西

动力节点—day04

最新文章

热门文章