Java语言学习笔记

Java 语言笔记

Java SE：Java标准版，用于桌面级应用和数据库开发；

Java EE：Java企业版，用于企业级开发；

Java ME：Java手持版，用于嵌入式和移动式开发。

 

Chapt 1

1)      Java区分大小写；

2)      Java编译程序时有扩展名，运行程序时没有扩展名；

3)      源程序里的类名要和文件名相同。

 

Chapt 2

1)      Java里面没有sizeof()操作符；

2)      Java标识符要以英文字母开头，由英文字母和数字组成；

3)      Java中switch表达式中可以使用表达式，常量以及枚举enum类型；

 

Chapt 6

1)      继承是面象对象编程的特点，同样也是Java的特点；

2)      继承是发生在类与类之间的，继承可以是单层继承，也可以是多层继承；

3)      多态是指对象在运行期和编译期具有两种状态，增强了代码灵活性和重用性；

4)      封装是指将变量和方法包含起来，通过特有的途径访问他们；

5)      创建类的实例：new class-name()；

6)      当使用的类和被使用的类在同一目录下时，就可以直接使用来创建类的实例；

7)      在不同目录下使用其他的类时：import defined-package-name.class-name;

8)      使用系统自带的类，有的不需要import引入，有的需要import引入，视情况而定；

9)      通过new关键字创建一个对象后，会有一个系统默认的初始值；

10)  局部变量在方法体里面创建，在方法体外是访问不到的；

11)  局部变量没有默认赋值；

12)  局部变量和成员变量的区别：

a)      成员变量可以被public，private，final，static等修饰；

b)      局部变量只能被final修饰；

c)      成员变量在堆里创建，局部变量在栈里创建；

d)      成员变量有系统默认值；

e)      局部变量没有系统默认值，必须手动赋值；

13)  Java的程序入口main就为一个方法，参数为String[]args，是个特殊的方法；

14)  方法的参数传递：传递类型为基本类型和对象引用类型时，都是利用值专递；

15)  任何类的父类都是Object；

 

 

Chapt 7

1)      创建一个包：package 包名

2)      创建包时注意：

a)      Package语句必须在第一行；

b)      Package语句只能有一个，不能有多个；

c)      包有多层的话用.分隔；

3)      如何使用包以及包的引入：

a)      Import 包名.*；//引用该包下面所有的类

b)      Import 包名.类名；//引用该包下面指定类名的类

c)      一段程序可以有多个import语句；

d)      Import语句要在package语句之后使用；

4)      静态引入：import static package-name.aaa.* or import staticpackage-name.aaa.function；

5)      静态引入会包下类的所有的静态方法和静态变量；

6)      默认访问权限和public权限很相似，不同的是默认访问权限不能访问不同包下面的类；

7)      Final关键字修饰的成员变量，其值是不能改变的，必须进行初始化，被final关键字修饰的成员变量是不会被默认初始化的；

8)      Final关键字修饰的变量要么直接在定义的时候初始化，要么就在构造函数里面对其进行初始化；

9)      Final修饰的局部变量和成员变量很相似，都是使其值不能不能被修改，被修饰的局部变量一旦被赋值后就不能修改了，如果在初见的时候没有对其赋值，那么在使用前还是可以对其赋值的，这就是局部变量和成员变量的不同；

10)  Final关键字修饰的方法，能被子类继承，但是不能被重写了；

11)  Static静态的意思就是在内存中只能有一份；

12)  静态变量属于类，不随着对象的创建而建立副本；

13)  被static修饰的成员变量不属于对象，而是属于类的；

14)  静态成员变量的访问有如下方式：类名.静态成员变量名  or  静态成员变量名称；

15)  静态成员变量不依赖于对象的加载而是依赖于类的加载的，当类加载后对象还没有加载，所以静态成员变量是属于类的，因此静态成员变量的生命周期要比非静态成员变量长，在静态方法中只能使用静态成员变量；

16)  这里注意，生命周期的问题，生命周期长的能使用生命周期短的，反之，不可。

17)  静态常量是指唯一的，不变的，只存在一份的数据，用static final来修饰；

18)  静态常量static和final没有先后之分，static修饰变量是属于类的，final是修饰成员变量的值是不能被修改的；

 

Chapt 8

1)      继承是为了让代码重用，提高效率；

2)      Java提供单一继承，通过接口可以实现多重继承；

3)      Java中被继承的类叫超类，继承超类的类叫子类；

4)      类的继承是通过关键字extends来修饰的，通过extends关键字表明前者具备后者的公共的成员变量和方法；

5)      Class 类名 extends 父类名称；

6)      所有类的父类为Object，如果类没有继承关系，那么父类就为Object，Object类的包路径为java.lang.Object；

7)      修饰符是修饰当前的成员变量的访问限制和状态的，主要有四个修饰符：public，private，default，protected；

8)      Public表明被它修饰的成员变量为公共类型，那么这个成员变量在任何包里都能访问，包括子类也能访问到；

9)      Private表明被它修饰的成员变量为私有类型，表示除了本类外，任何类都不能访问到这个成员变量，具有很好的保护性；

10)  Default是声明成员变量为默认类型，如果不给成员变量添加任何修饰符，就表示这个成员变量被修饰为default类型，在同一个包里的类或者子类是可以访问的，但是不同包里的类或者子类没有继承该成员变量，是访问不到的；

11)  Protected声明成员变量为保护类型，在同一包里和public类型是一样的，在不同包里的protected类型的成员变量就只能通过子类来访问，这个修饰符是区别于其他的修饰符的；

12)  被static修饰的类方法不能被重写（override），但是会被继承到子类；

13)  方法重载（overload），方法名称一样，根据方法参数列表的不同（个数和类型），以及返回值来区别调用方法；

14)  重写（override）方法时，如果返回类型是基本类型，则子类重写时返回类型也要一致，如果返回类型是引用，类型也要相同或者是父类返回类型引用的派生类即子类；

15)  就static方法不能被重写补充代码测试结果：static方法不能被重写，即使在子类写了和父类完全一样的方法，也只是对父类的static方法做了隐藏，用父类调用static方法名仍然可以调用到，但是如果不是static，那么重写之后，就相当于是方法被改变了，不论如何，你的调用都是你重写之后的方法，而不会调用到父类中的被重写的方法，区别是一种是static方法属于类而被隐藏，一种是直接的被重写，因此说static方法是不能被重写的；

16)  继承关系发生了，想用父类的方法就用super关键字引用；

17)  覆盖，重载，重写的区别：

a)      覆盖的方法在参数和返回值上是完全一样的，抛出异常也一样，且不能为private权限，否则，子类就是定义了一个新方法，并没有覆盖；

b)      重载是根据参数的列表不同而调用不同的方法；

c)      重写则是方法存在于父类，也存在于子类中，在运行期采用多态的形式，重写的方法不能比被重写的有更高的权限和更多的异常；

18)  Final与继承的关系：

a)        Final关键字修饰类时，说明其类不能有子类；

b)        Final关键字修饰方法时，说明该方法不能被重写；

c)        Final关键字修饰的成员变量的对象引用不能修改；

d)        Final关键字修饰的类里的方法默认被修饰为final；

19)  Abstract抽象类：抽象类里面最少要含有一个abstract抽象方法，让它的子类去实现这个抽象方法，当然抽象类里面也可以定义一些方法；

20)  Abstract抽象类不能实例化，抽象类的子类没有实现父类的抽象方法，就必须为抽象类；

21)  多态：基于继承的，运行时通过超类对象动态的绑定到相应的子类的方法上；

22)  Static方法和final方法是在编译的时候绑定的，其他的方法则是在运行期绑定，动态判断是什么类型；

23)  反射机制：类似于放大镜，通过类名，加载这个类，得到这个类的方法等信息；

24)  泛型：容器有默认的类型，在使用容器的时候为容器指明类型，就可以不用做类型转换；

 

Chapt 9

1)      接口：一个功能的集合，类似一种规定；

2)      定义一个接口：

a)        接口修饰符 interface 接口名称

{

         //成员变量和方法的声明；

}

3)      接口修饰符和类的修饰符是一样的，interface是定义接口的关键字；

4)      接口的成员变量默认是public static final类型的；

5)      接口不能声明成final，因为final类型的必须要实现；

6)      接口的定义遵循类的定义原则，接口也可以继承，类不能多继承，但可以多层继承，接口不但可以多层继承，还可以多继承；

7)      接口就是一个特殊的抽象类，抽象类里有抽象的方法和普通的方法；

8)      使用接口，即接口是如何实现的：

a)        类的修饰符 class 类名称 implements 接口名称

9)      接口和c/c++中的头文件声明，c文件定义一样的意思；

10)  抽象类和接口有点类似，抽象类需要其他的类来实现抽象类中的方法，接口是抽象类的特殊版本，接口里面的方法都为抽象的；

11)  判断类型：instanceof一般用于多态的时候，在代码中判断对象的引用类型具体是哪一种类型；

12)  Instanceof使用方法：对象的引用instanceof 类或者接口，返回类型是boolean型的；

13)  Instanceof不能比较基本类型数据，instanceof关键字右边只能为类或者接口；

 

 

Chapt 10

1)      构造器：就是类的构造函数，可以有修饰符，构造器的名称必须和类名相同，不能有返回值，参数可有，也可以没有；

2)      构造器可以带有修饰符，修饰符的权限和成员变量和方法的一致；

3)      构造器方法和普通方法的区别：

a)        构造器是为了创建类的对象实例；

b)        构造器没有返回值，void也不行；

c)        构造器的名称要和类名一致；

4)      实例化一个对象：new 构造器(参数列表)，根据参数列表匹配构造器；

5)      在不同的包下只要用import引入所需要的类后，使用构造器的方法就和在本类一样，当然构造器的权限要为public；

6)      发生继承关系时，子类的构造器方法默认调用父类的构造器方法，调用结束后再调用子类的构造器方法；

7)      构造器重载和方法重载几乎一样：根据参数表来判断，但是构造器不能被继承；

8)      在调用构造器的时候根据参数列表的不同由虚拟机来决定使用哪种构造器方法；

9)      因为继承关系，虚拟机会先去创建父类的对象，默认调用super()方法对父类的成员变量进行初始化，再回到子类来调用其构造器方法并进行初始化；

10)  如果每有显示的定义构造器，编译器就会默认的生成一个无参的构造器，一旦显示的定义的构造器，编译器就不会再生成了；

11)  为每个类写一个无参的构造器是个很好的习惯；

12)  单子模式：在一个时间段内对象只存在一份，就是把构造器修饰成private的，然后用一个public的方法返回该对象的引用；

13)  构造器在程序中的运行状况：

a)        加载要创建的对象的父类，以及成员变量和其他继承关系；

b)        加载该类的静态块和静态成员变量，并进行初始化工作；

c)        静态块和静态成员变量加载完毕后，创建对象，并加载非静态成员变量，并进行初始化；

d)        执行构造器的方法体，完成后该类的对象创建完毕；

e)        父类的运行顺序和该类一致，是一个递归的过程；

 

 

Chapt 11

1)      使用try-catch语句块来捕获异常时注意点：

a)        没有发生异常时，不会执行catch语句中的内容；

b)        避免程序自动退出；

c)        使用多个catch语句时，要将范围相对小的异常放在前面，将范围相对大的异常放在后面；

d)        Finally指定的语句块存放的是肯定会被执行到的语句；

e)        Try-catch-finally之间不能存在除注释外的任何语句；

2)      异常从大的角度分为：捕获异常和未捕获异常；

3)      所有的异常类都是继承Throwable类，而Throwable类是继承于Object类的，Throwable类有两个直接子类，Error类和Exception类，在Exception类中有一个RuntimeException类，在Exception类中的直接和间接子类中除去RuntimeException类的直接和间接子类，都是捕获异常（必须处理异常），其他的都是未捕获异常；

4)      对捕获异常的处理要注意，如果语句不可能出现捕获异常，但是程序中仍然对该语句进行捕获异常处理，就会认为出错；

5)      未捕获异常包括Error类以及直接子类和间接子类和RuntimeException类，以及相关的直接子类和间接子类，Error通常是硬件运行错误导致，RuntimeException通常是程序运行时引起的异常；

6)      未捕获异常是可以不进行异常处理的，如果不进行异常处理，编译的时候是完全没有问题的，但是在运行时会发生错误；

7)      抛出异常：有些情况下异常是不需要立即进行处理的，但是也必须进行异常处理，这时候就可以抛出异常；

8)      当一个程序段抛出异常时，如果自己无法处理异常，就可以抛出给上一层，知道抛出给main方法，如果还不能解决，则中断程序，显示异常；

9)      使用throws和throw语句抛出异常：

a)        Throws是在方法的声明语句中使用来抛出异常；

b)        Throw是在方法体内使用异常抛出；

10)  创建自定义的异常类，需要继承Exception类，Exception类包含了很多方法，可以得到很好的调试信息，如：printStackTrace()，toString()，getMessage()等；

 

Chapt 12

1)      当一个类做为另一个类的非静态成员时，则这个类就是个非静态内部类；

2)      分析一个内部类时，从两个方面看：一是本身是一个类，二是从外部来看，它是一个类的成员；

3)      静态方法中的局部内部类：注意静态成员的生命周期比非静态成员的要长；

 

Chapt 13

1)      每个程序中的main方法就是一个线程，一般被称为主线程，在主线程中可以启动多个子线程来执行；

2)      定义线程的方法有两种：一种是继承Thread类，一种是实现Runnable接口；

3)      和定义线程一样，创建线程对象也有两种方法；

4)      继承Thread类定义线程，在Thread类中有一个run方法，在定义的线程中需要重写这个方法，在重写的run方法中，执行该线程要执行的语句，当线程启动后，run方法中的程序就称为一条独立的执行线程；

5)      在继承Thread类定义线程方法中，创建线程对象和创建普通对象一样，这种方法只是针对使用继承Thread类定义线程的方法来说的；

6)      通过实现Runnable接口来定义线程：在Runnable接口中有一个抽象的run方法，在实现Runnable接口时，需要实现该run方法，该run方法就会作为一个执行线程的方法；

7)      这两种方法都需要定义一个run方法，不管是通过重写父类的方法，还是实现接口方法，run方法是一个线程的入口，是线程必须具有的；

8)      通过Runnable接口定义的线程中，直接创建对象并不是一个线程对象，要想创建线程对象，必须要借助Thread类：

a)        实现接口的类对象 class-name name = new class-name()；

b)        Thread t = new Thread(name);

9)      首先创建一个实现Runnable接口的类对象，然后将该对象作为Thread类的参数，从而创建了一个线程对象；

10)  仍然可以调用类的run方法来运行，但是这不表示创建了一个新的线程，如果想正确的启动一个线程，需要调用线程对象的start方法；

11)  在调用start方法后，就启动了线程，该线程和main方法的并列执行的线程，程序也就变成了一个多线程程序；

12)  线程只能被启动一次，也就是只能调用一次start方法，当多次调用start方法时，会发生异常；

13)  同时运行多个线程，定义多个实现Runnable接口的类，然后创建多个线程对象，用相应的线程对象调用start方法，就同时启动了多个线程；

14)  在同时运行多个线程时，运行结果不是唯一的，先执行哪个线程也是不确定的；

15)  线程的生命周期：新建状态，准备状态，运行状态，等待/阻塞状态和死亡状态：

a)        新建状态：当一个线程对象被创建后就处于新建状态，调用start方法后就进入准备状态；

b)        准备状态：新建状态的线程被调用start方法后就会进入准备状态，处于准备状态的线程随时都可能被系统选择进入运行状态，从而执行线程；

c)        运行状态：准备状态的线程一旦被系统选中，获得了CPU时间，就会进入运行状态，在运行状态中将执行线程类run方法中的语句，线程在运行状态随时都可能被调度程序调度回准备状态；

d)        等待/阻塞状态：线程调度的方法会将处于运行状态的线程调度到等待/阻塞状态，处于等嗲/阻塞状态的线程被解除后，不会立即回到运行状态，而是回到准备状态，等待系统的调度；

e)        死亡状态：线程中的run方法执行结束后，或者程序发生异常终止运行后，线程进入死亡状态，处于死亡状态的线程不能再使用start方法启动线程，但是可以做为普通的类再被使用；

16)  线程的调度：包括睡眠方法，设置优先级，让步方法，等

a)        睡眠方法：当线程处于运行状态时，调用sleep方法将线程从运行状体进入等待/阻塞状态，从而停止程序的运行，sleep方法睡眠线程的时候比传给参数的时间要长，因为线程进入准备状态后要等待系统的调度；

b)        Sleep方法被重载，是个静态方法，不依赖于对象，想让线程进入睡眠状态，并不是让线程调用sleep方法，而是让该线程执行sleep方法，然后sleep方法是可能导致捕获异常的，所以使用sleep方法时必须进行异常处理；

c)        线程优先级：很多系统中线程调度都是采用优先级方式来进行的，不同的线程具有不同的优先级，优先级高的线程就会占用更多的CPU和被执行的概率；

d)        Java中的优先级是从1到10来表示的，数字越大表示优先级越高，如果没有设置优先级，则线程的优先级为5，这也是线程默认值，但是子线程的默认值是和父线程相同的；

e)        调用方法：public final void setPriority(int i);来设置优先级的；

f)         Java中有两种线程让步方法――yield()方法：

                        i.             Yield让步方法：让线程让出当前的CPU，而将CPU让给哪一个线程不确定的，由系统来选择，使用yield方法会使得线程从运行状态进入到准备状态；

                      ii.             Public static void yield()；静态方法，也是和对象无关的，用类名调用；

                     iii.             Yield()方法有可能不成功，因为系统会有可能选择刚进入准备状态的线程重新运行；

g)        Java中另一种线程让步方法――join()方法：

                        i.             Join让步方法：将当前线程的CPU资源让给指定的线程；

                      ii.             Public final void join();

                     iii.             Public final void join(longmills);

                     iv.             Public final void join(longmills,int nanos);

                      v.             没有参数的join表示线程执行完后再执行其他线程，参数表示在参数时间内执行让步给的执行线程；

 

 

一本垃圾书，花了两天全部看完，一堆的错误，现在大概对java有了了解，和c++差不多，做个笔记，方便以后查阅。