Java开发实战经典学习笔记

2.4 java的关键字

2.6总结

第三章 Java基础程序设计

3.1

Java数据类型和C/Cxx数据类型会有区别。
Java 的字符是两字节，c是一字节。
这里需要参考其他人的博客，也需要自己重新总结。

3.2.6基本数据类型的默认值

3.3.1

自动转换，没显式的说明转换，自己悄悄给你转了。
任何数据类型都向String转型

改正

3.3.2
数据类型强制转换，程序员代码里面直接写上转换方式。

3.4
3.4.1
关系运算符
C 语言把任何非零和非空的值假定为 true，把零或 null 假定为 false。Java语言的判断是 if(布尔表达式)，如果括号里
面是赋值就会报错，

逻辑运算符

|| ，&&， |， & ，
这里需要参考其他人的博客，也需要自己重新总结。

a&b 算完a算b，然后合计a和b得出来的最后结果
。
a&&b 算完a如果发现是假的，然后就不算了等式是假的。如果发现是真的，然后算b。
这就是短路与的意思。而短路或也是相同的运算过程。

这里需要参考其他人的博客，也需要自己重新总结。

运算符优先级

3.6 总结

3.7习题：

1.
public static void main(String[] args) {
    //ge wei
    int g = 0;
    //shi wei
    int s = 0;
    //bai wei
    int b = 0;
    for(int i = 2;i<=999;i++){
        g = i % 10;
        s = (i % 100) / 10;
        b = i / 100;
        if (i == (g*g*g + s*s*s + b*b*b)){
            System.out.println(i + "\t");
        }
    }

}
2.
public static void main(String[] args) {
    int a = 10;
    int b = 20;
    int temp =0;
    System.out.println("before change ");
    System.out.println("a = "+ a);
    System.out.println("b = "+ b);

    temp = a;
    a = b;
    b = temp;

    System.out.println("after change ");
    System.out.println("a = "+ a);
    System.out.println("b = "+ b);


}
3.
public static void main(String[] args) {
    int a = 10;
    int b = 20;
    int c = 30;
    int max = -1 ;
    max =a;
    if (a > b){
        max = a;
    }
    else {
        max =b;
    }
    if (max > c){
        System.out.println("max is " + max);
    }
    else{
        System.out.println("max is "+ c);
    }
}
4.
public static void main(String[] args) {
    //int a = 10;
    //int b = 20;
    //int c = 30;

    // zhaodaodeshu
    int m = -1;
    for (int i = 0; i < 999; i++) {
        m = i / 3 / 5 / 7;
        if (m * 3 * 5 * 7 == i) {
            System.out.println(i);
        }
    }
}
5.
public static void main(String[] args) {
    int sum1 = 0;
    int sum2 = 0;
    int sum3 = 0;
    int i = 100;
    int j = 100;
    int k = 100;

    while (i<=200){
        sum1 = sum1 + i;
        i++;
    }
    System.out.println("sum1 = "+sum1);

    do {
        sum2 = sum2 + j;
        j++;
    }while (j <= 200);
    System.out.println("sum2 = "+sum2);

    for ( ; k <= 200 ; k++) {
        sum3 = sum3 + k;
    }
    System.out.println("sum3 = "+sum3);

}
6.
public static void main(String[] args) {
    int sum = 0;
    int i = 13;
    boolean isEven = true;

    for(i = 13;i <= 1003;i = i + 10){
        if (isEven){
            sum = sum + i;
            isEven = false;
        }
        else {
            sum = sum - i;
            isEven = true;
        }

    }
    System.out.println("sum = "+ sum);
}
7.

8.
9.
10.
11. 小心数据溢出。
public static void main(String[] args) {
    long sum=0;

    for (int i =1;i<21;i++){
        sum = sum+ recure(i);
    }
    System.out.print(sum);

}
private static long recure(int i) {
    if (i==1){
        return 1;
    }
    return  i * recure(i-1);
}
12.

第四章 数组与方法

4.1.1
要使用Java的数组必须经过声明数组和分配内存给数组两个步骤。

数组的大小？
这里需要参考其他人的博客，也需要自己重新总结。

4.1.3 数据静态初始化

int score [] = {1,2,3,4,5,6};

4.1.5 二维数组

4.2 方法的声明及使用
4.2.1
在主方法中调用的方法需要定义成这样：

方法命名驼峰法。

方法的重载： 方法名称相同，参数类型和个数不同才是重载。与方法的返回类型无关。

4.3数组的引用传递
4.3.1
如果向方法传递了一个数组，该方法修改了数组，那么即使方法没有返回值也会修改数组。因为数组是引用类型。


4.4 Java新特性对数组的支持

可变参数 foreach输出 jdk1.5以后的。

4.5总结

这里需要做习题，把答案贴上来。

5.1面向对象的基本概念
封装

继承

多态
方法重载，类内多个方法使用同一个名字。
对象重载，子类对象可以与父类对象进行相互转换。
这里需要细致看其他人的博客。

5.2 .1类与对象的关系
类抽象，对象具体。

5.2.2


5.2.3 对象的创建及使用

这里可以看出和数组的定义相似。他们都属于引用数据类型，只要是引用数据类型都可以使用如上定义样式。

下面是对象在内存中的分配情况。


这里需要细致看其他人的博客，java与c++内存分配异同。

5.2.4 创建多个对象

创建两个对象。

下面是内存分布。

类属于引用数据类型，而且从数组的使用上也可以发现，引用数据类型就是指一段堆内存空间可以同时被多个栈内存指向。

另外一个例子。

内存分布。

另外一个例子。

内存分布以及垃圾空间释放。

5.3封装性
1）一个例子。

这个例子说明了：

2）遇见这个矛盾，就需要我们解决：
这里设置了私有访问权限，但是会出错。

为了解决属性必须封装且又必须访问的矛盾，在Java开发中对于私有属性的访问有了以下的明确定义：“只要是被封装的属性，则必须通过setter和getter方法设置和取得”。

3）然后回到开头的例子。


4）这里完善一下。


总结这个过程：
这里需要细致思考。

接下来就是一些知识的延申。

5.4构造方法
牢记以下几点：
1.构造方法的名称必须和类名称一致。
2.构造方法的声明处不能有任何返回值类型的声明。
3.不能在构造方法中使用return返回一个值。

只要是类就必须存在构造方法，如果没有写，系统自动给你生成一个无参数的，什么都不做的构造方法。但是如果有了构造方法，那么就不再生成默认的构造方法。

以上的程序可以用类图表示为：

5.5匿名对象与之前的对象不同，此处没有任何栈内存引用它，所以此对象使用一次之后就等待被垃圾收集机制回收。

5.6

5.7
5.7.2 String的内容比较

==的比较是比较地址。

equals比较是比较内容。
这里可以延伸null和“”的比较。这里需要细致思考。

5.7.3 String 两种实例化方式的区别

5.7.4 字符串的内容不可改变。
字符串的内容一旦声明则不可改变。

一个例子。

5.7.5

5.8 引用传递及基本应用
5.8.1
例子1


例子2

例子3


5.8.2 接收本类的引用


5.8.3 一对一关系

不知道说的是什么意思。这里需要细致思考。
5.9 this 关键字
this可以强调本类中的方法，还有以下作用：
1.表示类中的属性
2.可以使用this 调用本类的构造方法
3.this表示当前对象。

5.9.2 使用this调用构造方法

this（）；
这样的调用必须放在首行。



5.9.3 this表示当前对象

5.10 static关键字
5.10.1 static 声明属性
让属性跟类绑定在一起。例如有100个对象，他们都需要对自身的属性，比如说区域，都需要改成中国，那么就不需要每个对象都改动自身的属性，只需要改动一次静态属性就可以了。

例如：这里country是static修饰的，他的内存为:

注意：
一个类的公共属性应该由类进行修改，不应该由对象进行修改。

5.10.2 static 方法 也叫类方法
非static声明的方法可以去调用static声明的属性或方法，但是static声明的方法是不能调用非static类型声明的属性或者方法和。

报错


5.10.3
5.10.4 理解main方法
main方法的参数如果有空格，可以拿“”引起来。
如： java StaticDemo 08 “Hello World!!” “li xing hua”

这里解释了main方法为什么是如此格式，而且也是一直强调如果一个方法被主方法调用，就必须按以下格式声明：
“ public static 返回类型 方法名（参数列表）{}"
此刻也能理解了为什么在主方法里面调用的方法要加上 static 关键字。

5.11代码块
普通代码块，构造代码块，静态代码块，同步代码块。
5.11.1 普通

5.11.2构造
构造块优先于构造方法执行，而且每次实例化对象时都会执行构造块中的代码，会执行多次。
5.11.3 静态块

静态代码块优先于主方法执行，而在类中定义的静态块会优先于构造块执行，而且不管有多少个对象产生，静态代码块只执行一次。

5.12 构造方法私有化
5.12.1 问题的提出
5.12.2解决

5.12.3以上程序的意义


5.12 对象数组
使用对象数组一定要先开辟空间，然后因为是引用类型，所以每个对象都是null值，需要在使用的时候分别进行实例化操作。

与数组初始化方式一样，对象数组也分为静态初始化和动态初始化。
主方法里面的 String args[] 参数也是对象数组。

5.14 内部类。

缺点：破坏了一个类的基本机构。
优点：可以方便的访问外部类中的私有属性。
5.14.2 用static定义内部类

为什么 static 内部类可以访问外部类的属性? 这里需要细致思考。

5.14.3 在外部访问内部类



5.14.4 在方法中定义内部类

5.15 实例讲解。



会遇到读完代码感觉很空洞，把书本扔了自己开发写不来的情况，很痛苦。

5.15.2 单向链表实现（1）
5.15.3 单向链表实现（2）

5.16总结


9.String为什么可以直接赋值？它做了什么和其它的类不一样？
14.比较陌生需要多看看。
习题没有做。

6面向对象（高级篇）
6.1继承的基本概念
只允许多层继承，不能多重继承。
下面是类图表示。


6.2
6.2.1

super（）语法，调用父类的无参构造方法。

6.2.2方法的覆写
如果子类覆写的方法权限大于父类同名的方法，则子类对象调用的将是被覆写后的方法。
如果子类覆写的方法权限小于或等于父类同名的方法，则出现错误提示。

如果现在要在子类的方法中访问父类的方法，则使用super关键字即可。“super.方法（）".

属性的覆写。
子类中直接访问就用“就近访问原则”，要调用父类属性，直接使用“super.属性”格式。

方法的重载和覆写区别。

super和this的区别：

6.3 范例
看不懂。
6.4 final关键字

6.5 抽象类的基本概念

其他地方与普通类的组成基本都一样。
需要注意的是子类必须覆写抽象类中的全部抽象方法。
例子：
类图表示

抽象类注意：

例子

既然子类可以通过调用抽象类中的构造方法，那么也可以直接在子类指定调用父类中的指定参数的构造方法。
总结：

6.6接口的基本概念

接口的图形表示：

与抽象类一样，接口若要使用也必须通过子类，子类通过implements关键字实现接口。

6.7 对象的多态性

例子：

例子：

多态的实际用处：

6.8 instanceof关键字

例子：


看不懂。
6.9抽象类与接口的应用
6.9.1 微抽象类与接口实例化
在java中可以通过对象的多态性为抽象类和接口实例化，这样再使用抽象类和接口时即可调用本子类中
所覆写过的方法。

6.9.2 抽象类的实际应用–模板设计
6.9.3 接口的实际应用–制定标准
6.9.4 设计模式–工厂设计

6.9.5 设计模式 --代理设计

程序的执行流程：
6.9.6设计模式–适配器设计


6.9.7内部类的扩展

6.9.8抽象类与接口之间的关系

补充：

6.10实例分析：宠物医院

没有写代码。

6.11 Object类
Java中所有的类都有一个公共的父类Object，一个类只要没有明显地继承一个类，则肯定是Object类的子类。

6.11.2主要方法

6.11.3 接收任意引用类型的对象


6.12 包装类

6.12.2 装箱与拆箱

JDK1.5之前需要手动装箱拆箱操作，之后提供来自动的装箱及拆箱操作。

6.12.3 包装类应用

6.13 匿名内部类

6.14总结

6.15
没有写习题。

7 异常的捕获及处理

7.1

7.1.1 为什么需要异常处理

7.1.2 在程序中使用异常处理。

7.1.4 Java的异常处理机制

注意：在Java中所有捕获范围小的异常必须放在捕获大的异常之前，否则程序在编译时就会出现错误提示。

7.2throws与throw关键字
7.2.1 throws

例子：

例子：

7.2.2 throw关键字

7.2.3 范例 throw与throws的应用

7.3 Exception类与RuntimeException类

7.4自定义异常类

7.5断言

7.6总结

7.7
没有写习题。

8 包及访问控制权限

8.1 包的概念及使用

8.1.2 import 语句

例子

8.1.3系统常见包

8.1.4静态导入

8.2 jar命令的使用

8.3 访问控制权限

8.4 Java命名规范

8.5 本章要点

8.6

习题没有做。

9.多线程
9.1

9.2
9.2.1继承Thread类

9.2.2 实现Runnable接口

例子：

9.2.3Thread类和Runnable接口

9.3线程的状态
9.4线程操作的相关方法

9.4.1 取得和设置线程名称
在线程操作中，如果没有为一个线程指定一个名称，则系统在使用时会为线程分配一个名称，名称的格式为 Thread-Xx。
在Thread类中存在一个static类型的属性，用于为线程自动命名。

9.4.2 判断线程是否启动

9.4.3 线程的强制执行

12.13.4
注意：