疯狂Java讲义 读书笔记（一）

24.引用变量类型：1、编译时类型：由声明该变量时使用的类型决定 2、运行时类型：由实际赋给该变量的对象决定 3、编译时类型和运行时类型不同时，就出现了所谓的多态 4、引用变量在编译阶段只能调用其编译时类型所具有的方法，但运行时则执行它运行时类型所具有的方法（可用强制类型转换解决问题）。

25.向上转型：把一个子类对象直接赋值给父类引用变量；强制类型转换：把一个父类对象赋给子类引用变量

26多态：1、相同类型的变量，调用同一个方法时呈现出多种不同的行为特征叫做多态 2、成员变量不存在多态，总是调用父类的值

27.instanceof：判断前面的对象是否是后面的类，或者其子类、实现类的实例

String str="str";
//true
System.out.println(str instanceof Object);
Object obj=new Object();
//false
System.out.println(obj instanceof String);

28.继承与组合：1继承代表"is a"，组合代表"has a" 2.创建子类对象，系统会为其父类所定义的实例变量分配内存空间，因此继承和组合在系统开销上没有太大的区别

29.初始化块：1.初始化块在构造器之前执行（编译后初始化块的内容会还原到构造器中） 2.静态初始化块在普通初始化块之前执行

30.包装类：包装类的实例可以与数值类型直接比较

31.toString：自定义类时，尽量重写类的toString方法，便于输出实例的值

32.==与equals：1.对于引用类型，只有二者指向同一个对象，==才会等于true  2.String类型情况如下，编译时确定的数据在常量池中，运行时生成的数据在堆内存中

    // s1直接引用常量池中的"疯狂Java"
        String s1 = "疯狂Java";
        String s2 = "疯狂";
        String s3 = "Java";
        // s4后面的字符串值可以在编译时就确定下来
        // s4直接引用常量池中的"疯狂Java"
        String s4 = "疯狂" + "Java";
        // s5后面的字符串值可以在编译时就确定下来
        // s5直接引用常量池中的"疯狂Java"
        String s5 = "疯" + "狂" + "Java";
        // s6后面的字符串值不能在编译时就确定下来，
        // 不能引用常量池中的字符串
        String s6 = s2 + s3;
        // 使用new调用构造器将会创建一个新的String对象，
        // s7引用堆内存中新创建的String对象
        String s7 = new String("疯狂Java");
        System.out.println(s1 == s4); // 输出true
        System.out.println(s1 == s5); // 输出true
        System.out.println(s1 == s6); // 输出false
        System.out.println(s1 == s7); // 输出false

33.重写equals的条件：1.自反性：x.equals(x)=true 2.对称性：若x.equals(y)=true，则y.equals(x)=true 3.传递性：若x.equals(y)=true,y.equals(z)=true,则x.equals(z)=true 4.一致性：只要x.equals(y)=true且x,y不变，无论调用多少次结果都不变 5.对任何不适Null的x,x.equals(null)=false 6.equals相同，则hashcode相同

34.null类型的实例可以访问类的静态方法和静态变量，在底层是通过该实例的类去访问的

35.final：1.final变量不是不能被赋值，而是不能被改变 2.final变量必须由程序员显示的指定初始值 3.final修饰引用变量时，引用地址不可以改变，对象可以改变 4.final修饰的方式不能被重写，但是可以被重载

36.宏变量：定义final变量时就为该变量指定了初始值，而且可以在编译时就确定下来，编译器会把程序中所有用到改变量的地方直接替换成该变量的值（进入常量池）

37.不可变类：1.private final修饰所有成员变量 2.只有getter没有setter

38.缓存池：先进先出缓存实例，重写了equals和hsahcode

class CacheImmutale
{
    private static int MAX_SIZE = 10;
    // 使用数组来缓存已有的实例
    private static CacheImmutale[] cache
        = new CacheImmutale[MAX_SIZE];
    // 记录缓存实例在缓存中的位置,cache[pos-1]是最新缓存的实例
    private static int pos = 0;
    private final String name;
    private CacheImmutale(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return name;
    }
    public static CacheImmutale valueOf(String name)
    {
        // 遍历已缓存的对象，
        for (int i = 0 ; i < MAX_SIZE; i++)
        {
            // 如果已有相同实例，直接返回该缓存的实例
            if (cache[i] != null
                && cache[i].getName().equals(name))
            {
                return cache[i];
            }
        }
        // 如果缓存池已满
        if (pos == MAX_SIZE)
        {
            // 把缓存的第一个对象覆盖，即把刚刚生成的对象放在缓存池的最开始位置。
            cache[0] = new CacheImmutale(name);
            // 把pos设为1
            pos = 1;
        }
        else
        {
            // 把新创建的对象缓存起来，pos加1
            cache[pos++] = new CacheImmutale(name);
        }
        return cache[pos - 1];

    }
    public boolean equals(Object obj)
    {
        if(this == obj)
        {
            return true;
        }
        if (obj != null && obj.getClass() == CacheImmutale.class)
        {
            CacheImmutale ci = (CacheImmutale)obj;
            return name.equals(ci.getName());
        }
        return false;
    }
    public int hashCode()
    {
        return name.hashCode();
    }
}
public class CacheImmutaleTest
{
    public static void main(String[] args)
    {
        CacheImmutale c1 = CacheImmutale.valueOf("hello");
        CacheImmutale c2 = CacheImmutale.valueOf("hello");
        // 下面代码将输出true
        System.out.println(c1 == c2);
    }
}

39.默认方法：1.JDK1.8后新增的方法，在接口中一共有三种方法，抽象方法（abstract），类方法（static），默认方法（default）,后两者必须有方法实现 2.使用接口的实例来调用默认方法

40.抽象类：抽象类作为多个子类的抽象父类，可以被当成系统实现过程的中间产品，这个中间产品已经实现了系统的部分功能，但这个产品依然不能当成最终产品，必须由进一步的完善，

41.内部类：1.提供更好的封装 2.内部类成员可以直接访问外部类的私有数据 3.匿名内部类适用于创建只需要一次使用的类 4.局部内部类和匿名内部类不是类成员 5.包含内部类的类被称为外部类

42.非静态内部类：1.非静态内部类对象里保存了一个外部类的引用 2.外部类对象访问非静态内部类成员时，可能非静态普通内部类对象根本不存在 3.不允许在非静态内部类定义静态成员

43.静态内部类：1.静态内部类可以包含静态成员和非静态成员 2.静态内部类是外部类的类相关，静态内部类对象寄生在外部类的类本身中，只持有外部类的类引用，没有外部类的对象引用

（编辑：江门站长网）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!