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

李刚老师的《疯狂Java讲义》（第三版）是我的启蒙作品，前前后后一共看了3遍，每次都有新的认识。

接下来的一段时间就将一些经典的知识记录下来。

1.计算机高级语言的执行方式分为编译型和解释型，前者运行高效但不能跨平台（C,C++,Object-C），后台可以跨平台但效率不高（Ruby，Python）。Java比较特殊，先编译生成.class，再在JVM中解释。

2.垃圾回收机制：依靠垃圾回收算法，何时回收对Java程序员而言具有透明性，因此要养成良好的习惯——对于不需要的对象，不要引用他们。（在堆中进行回收）

3.Java是强类型语言：所有类变量必须先声明后使用，指定类型的变量只能接受与类型相匹配的值。

4.Java支持两种类型：1、基本类型：布尔类型、数值类型 2.引用类型：类、接口、数组。

5.强制类型转化：造成溢出时，之前一直觉得19.745会变成19（实在汗颜），其实是转换成二进制后再进行截取。

6.常量池：在编译期被确定，并已被保存在.class文件中的一些数据。包括类、方法、接口中的常量，也包括字符串常量。

7.switch语句：控制表达式的数据类型只能是byte,short,char,int,枚举,String.

8.break和continue可以通过标签跳到指定的循环层

public class BreakTest2
{
    public static void main(String[] args)
    {
        outer:
        for (int i = 0 ; i < 5 ; i++ )
        {
            for (int j = 0; j < 3 ; j++ )
            {
                System.out.println("i的值为:" + i + "  j的值为:" + j);
                if (j == 1)
                {
                    break outer;
                }
            }
        }
    }
}

9.栈和堆：1、当一个方法执行时，每个方法都会建立自己的内存栈，在这个方法内定义的变量将会逐个放入这块栈内存里，随着方法的执行结束，这个方法的内存栈也将自动销毁。因此，所有在方法中定义的局部变量都是放在栈内存中；2、当我们在程序中创建一个对象是，这个对象将被保存到运行是数据区中，以便反复利用，这个运行是数据区就是堆内存。堆内存中的对象不会因方法结束而销毁，就算方法结束后，这个对象还可能被另一个变量所引用，则这个对象不会销毁，只有当一个变量没有任何引用变量引用它，那么系统的垃圾回收器才会在合适的时候回收它；

10.Arrays：Java8增加的工具类，在java.util包下，支持并发编程

        // 定义一个a数组
        int[] a = new int[]{3, 4 , 5, 6};
        // 定义一个a2数组
        int[] a2 = new int[]{3, 4 , 5, 6};
        // a数组和a2数组的长度相等，每个元素依次相等，将输出true
        System.out.println("a数组和a2数组是否相等："
            + Arrays.equals(a , a2));
        // 通过复制a数组，生成一个新的b数组
        int[] b = Arrays.copyOf(a, 6);
        System.out.println("a数组和b数组是否相等："
            + Arrays.equals(a , b));
        // 输出b数组的元素，将输出[3, 4, 5, 6, 0, 0]
        System.out.println("b数组的元素为："
            + Arrays.toString(b));
        // 将b数组的第3个元素（包括）到第5个元素（不包括）赋为1
        Arrays.fill(b , 2, 4 , 1);
        // 输出b数组的元素，将输出[3, 4, 1, 1, 0, 0]
        System.out.println("b数组的元素为："
            + Arrays.toString(b));
        // 对b数组进行排序
        Arrays.sort(b);
        // 输出b数组的元素，将输出[0, 0, 1, 1, 3, 4]
        System.out.println("b数组的元素为："
            + Arrays.toString(b));
    }

11.Java语言通过new关键字调用构造器。

12.this关键字：1、让类中的一个方法，访问该类里的另一个方法或者实例变量。2、this所代表的对象是不确定的，但他的类是确定的。3、在构造器中，this代表该构造器正在初始化的对象。4、如果在某个方法中把this作为返回值，则可以多次连续调用同一个方法。

public class ReturnThis
{
    public int age;
    public ReturnThis grow()
    {
        age++;
        // return this返回调用该方法的对象
        return this;
    }
    public static void main(String[] args)
    {
        ReturnThis rt = new ReturnThis();
        // 可以连续调用同一个方法
        rt.grow()
            .grow()
            .grow();
        System.out.println("rt的age成员变量值是:" + rt.age);
    }
}

13.static:不要使用对象去调用static修饰的成员变量，要使用类去调用。

14.值传递：将实际参数的副本传入方法内，参数本身不会受到任何影响。

15.形参可变的方法：定义方法时，在最后一个形参的类型后增加三个点(...)。多个参数值被当成数组传入。与传入数组相比，形参可变更加简洁，但一个方法只能有一个可变形参。

public class Varargs
{
    // 定义了形参个数可变的方法
    public static void test(int a , String... books)
    {
        // books被当成数组处理
        for (String tmp : books)
        {
            System.out.println(tmp);
        }
        // 输出整数变量a的值
        System.out.println(a);
    }
    public static void main(String[] args)
    {
        // 调用test方法
        test(5 , "疯狂Java讲义" , "轻量级Java EE企业应用实战");
    }
}

16.递归算法：一个方法调用自身，一定要向已知方向递归。

17.局部变量：形参（方法签名中定义的变量），方法局部变量（在方法内定义），代码块局部变量（在代码块内定义），局部变量不属于任何类或者实例，它总是保存在其所在方法的栈内存中。

18.封装：类的成员变量不直接暴露，而是通过方法实现操作和访问，以便于在方法中添加一些限制条件

19.高内聚：尽可能把模块的内部数据、功能实现细节隐藏在模块内部独立完成，不允许外部直接干预；低耦合：仅暴露少量的方法给外部使用。

20.静态导入：JDK1.5增加的导包方法，用于导入包内的静态成员 import static package...

21.构造器：1、构造器是创建Java对象的重要途径，但这个对象并不是完全由构造器负责创建的。2、子类的构造器必定会调用其父类的构造器（没有super和this时默认调用无参的构造器）。

22.方法重写（覆盖）原则：1、两同：方法名、参数列表相同 2、两小：子类方法返回值<=父类方法返回值 3、一大：子类方法访问权限>=父类方法访问权限

23.当程序创建一个子类对象时，系统不仅会为该类中定义的实例变量分配内存，也会为它从父类继承得到的所有实例变量分配内存。

（编辑：PHP编程网 - 黄冈站长网）

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