完整版Java笔记总结Word文件下载.docx

完整版Java笔记总结Word文件下载.docx

《完整版Java笔记总结Word文件下载.docx》由会员分享，可在线阅读，更多相关《完整版Java笔记总结Word文件下载.docx（9页珍藏版）》请在冰点文库上搜索。

b）int类型转换成byte类型很容易造成精度丢失。

因为int类型变量是32位，byte类型只有8位，所以在转换过程中会丢失int类型的高3位字节。

c）在用”双字符“型运算符（+=、-=之类的）运算时，强制类型会自动完成，不用程序显示的声明。

13、三元运算符：

判断条件？

表达式1：

表达式2；

——若条件成立，执行表达式1，否则执行表达式2。

14、跳转语句：

a）break：

i.用于switch语句，终止某case并跳出switch结构。

ii.用于循环语句，跳出循环语句，执行后面的程序。

b）continue——只用于循环语句中：

终止本次循环，执行下一次循环。

15、方法重载：

a）2个条件：

方法名相同、参数个数或参数类型不同。

b）与返回值类型无关。

16、数组：

a）定义数组：

i.类型[]数组名=new类型[数组长度]

//这种定义方式只指定了长度，元素的初值由系统自动赋0。

（动态初始化）

ii.类型[]数组名=new类型[]{元素，元素，......}

iii.类型[]数组名={元素，元素，......}

//这2种称为静态初始化。

17、冒泡排序：

a）若有n个元素，则进行n-1轮排序（n-1次外循环）

b）第1轮排序，元素之间进行n-1次比较；

第2轮排序进行n-2次排序......最后1轮只进行1次比较。

c）外循环条件：

i<

arr.length

d）内循环条件：

j<

arr.length-i-1

18、二维数组：

a）定义方式1：

类型[][]变量名=new类型[几行][几列];

b）可理解为数组的数组——例arr[0][1]-->

数组名arr[0]，第二个元素[1];

c）二维数组的长度由”[几行]“确定！

！

d）定义方式2：

类型[][]变量名=new类型[几行][];

//行数确定，列数不确定——每行可以随便赋值。

e）定义方式3：

类型[][]变量名={{,...,...,...}，{}，{}，......}

//这种行数、列数都不确定。

大括号内的每个大括号代表一行的元素，每行有多少个元素取决于内大括号中元素的个数。

19、面向对象的特点：

封装性、继承性、多态性。

20、在创建变量后，JVM运行程序时，会自动初始化变量。

引用型变量为null。

21、垃圾对象——没有变量引用的对象。

22、类的封装：

将类中的属性私有化。

外界访问私有属性时只能通过该属性的getxxx（）方法。

a）//择Generategetterandsetter-->

自动生成set和get方法。

23、构造方法：

实例化对象。

a）可以用带参数的构造方法在实例化对象时就给私有属性赋值。

b）好的程序员应该为每个类写一个无参构造方法。

c）定义构造方法的条件：

i.方法名与类名相同。

ii.没有返回值的声明。

iii.方法中不能有return返回值。

24、this关键字

a）this指代该类实例化的对象。

所以可以用this.xx的方式调用成员。

b）在成员方法中使用this关键字，避免参数名与属性名相同。

c）用this关键字调用构造方法

i.只能在构造方法中用this调用其他构造方法；

ii.此时this语句必须位于第1行，并且只能出现一次

iii.不能在一个类的两个构造方法中互相调用。

25、static关键字

a）静态变量：

i.用static修饰的变量

ii.静态变量被所有实例共享

iii.可以使用“类名.变量名”的形式来访问。

iv.只能修饰成员变量

b）静态方法

i.希望在不创建对象的情况下也能条用类中的某个方法，那就用static关键字休息这个方法

ii.静态方法只能访问静态成员！

//因为非静态成员必须先创建对象才能访问，而静态方法在被调用的时候可以不创建对象——那么就没有非静态成员可供访用。

c）静态代码块

i.当类被加载时，静态代码会执行一次。

而类只会被加载一次，所以静态代码块只会被执行一次。

ii.通常会用静态代码块对类的成员变量进行初始化。

d）单例模式

i.privatestatic类名INSTANCE=new类名（）;

//私有成员变量——自己创建一个对象。

private类名（）{};

//私有的构造方法，只能内部访问

publicstatic类名getInstance（）{returnINSTANCE;

}

//定义静态方法，返回自己的实例对象。

ii.第二种单例模式创建方法。

1.Private类名（）{}//私有的构造方法，只能在类的内部被调用。

2.publicstaticfianl类名INSTANCE=new类名（）;

//公有的不能被修改的静态成员对象。

26、内部类——定义在类里面的类

a）成员内部类

i.相当于成员方法，可以访问外部类的所有成员；

ii.因为成员内部类相当于成员方法，所以想要创建内部类对象时，必须得用外部类的对象去创建内部类对象：

1.外部类名.内部类名变量名=new外部类名（）.new内部类名（）;

b）静态内部类

i.用static修饰的成员内部类，也相当于静态方法。

只能访问外部类的静态成员。

ii.因为静态，所以在创建内部类对象时，可以不用先创建外部类对象：

1.外部类名.内部类名变量名=new外部类名.内部类名（）;

iii.静态内部类中可以定义静态成员，非静态内部类则不可。

c）方法内部类

i.在方法中定义的类，只能在当前方法中被使用。

27、当一个对象被当成垃圾从内存中释放时，它的finalize（）方法会被自动调用。

28、继承

a）继承关键字：

extends。

b）格式：

ClassAextendsB{}

c）单继承——一个类只能有一个直接父类。

29、重写父类方法

a）条件：

方法名、参数、返回值类型3个都相同。

b）重写之后，子类调用被重写的方法时，就是调用自己写的方法。

c）重写应用：

i.应用对象是父类的公有方法。

重载应用的对象是类本身的方法。

ii.重写父类不适合子类的方法

iii.实现接口。

30、super关键字

a）调用父类成员变量和成员方法：

i.super.成员变量;

ii.super.成员方法（参数1,参数2,...）;

b）调用父类的构造方法

i.super（参数1,参数2,...）;

ii.必须位于子类的构造方法的第一行，且只能出现一次。

iii.在实例化子类时，系统会在子类的构造方法中调用父类的构造方法——如果子类的构造方法中没有调用父类的构造方法，系统会自动调用父类的无参构造方法。

所以每个类的无参构造方法一定不要漏了！

子类也可以显示的调用父类的有参或无参构造法方法。

c）解决重写了父类方法之后，不能调用父类方法的问题。

31、final关键字

a）final修饰的类不能被继承

b）final修饰的方法不能被子类重写

c）final修饰的变量是常量，不能被修改，且必须在定义时为变量赋值。

32、抽象类

a）关键字abstract

b）抽象方法：

abstractvoidshout（）{}；

——没有方法体。

c）包含抽象方法的类必须声明为abstract类：

abstractclassAnimal{}

d）抽象类可以不包含任何抽象方法，只需用abstract修饰。

e）抽象方法不能直接实例化，只能让子类实例化。

33、接口

a）定义关键字：

interface——interfaceAnimal{}

b）接口中的方法被默认修饰为：

publicabstract——抽象方法。

c）接口中的变量被默认修饰为:

publicstaticfinal——全局常量

i.所以变量最好用全大写表示。

d）因为方法都是抽象的，所以必须定义一个类来实现（implements）接口——ClassAimplementsB{}

e）接口之间可以继承——interfaceCextendsB{}

f）一个类可以实现多个接口，接口直接间用逗号隔开。

g）一个类可以在继承一个类的同时，实现其它的接口。

h）如果一个类去实现接口的话，那么这个类必须实现接口中所有的方法。

34、多态

a）方法上的多态

i.类内部方法的重载

ii.子类对父类方法的重写

b）对象上的多态性

i.假设父类：

A；

子类B

Bb=newB（）;

ii.对象的自动向上转型：

Aa=b;

//子类对象，变成了父类对象。

1.虽然a指向A的对象，但是如果B重写了A的方法，那a调用的还是B中的方法。

iii.对象的强制向下转型

1.若Aa=newA（）;

2.Bb=（B）a;

//父类对象变成了子类对象。

3.这时对象b调用的是子类的重写的方法。

4.注意：

对象发生强制向下转型之前，必须保证已经发生了向上转型，否则会出异常。

35、异常

a）异常类分为：

编译时异常、运行时异常

b）异常处理机制：

i.try...catch...finally

1.try代码包含可能发生异常的Java语句，catch块中包含针对一场进行处理的代码。

2.当发生异常时，系统将异常信息封装成一个异常对象传递给catch代码块。

所以catch需要定义1个对应的异常类变量。

3.finally代码块包含，无论发生什么异常都要执行的代码。

常用于关闭系统资源。

ii.throws关键字声明抛出异常，调用者对其处理。

这种方法能通过编译，但是发生异常后就会终止运行。

c）自定义异常

i.首先定义一个继承Exception异常的异常类；

异常类中编写一个无参构造方法（调用父类无参构造方法），再编写一个带String参数的构造方法（也调用父类的带Stirng参数的构造方法）。

ii.再定义一个测试类，定义要调用的方法，并在此方法后面用throws关键字声明抛出自定义异常；

再在方法体内判断什么时候用thrownew自定义异常（“要打印的信息”）。

//声明自定义异常对象。

iii.最后在测试类的main方法中，

iv.try{...}

catch（...）{System.out.printlan（e.getMessage）}

finally{...}

36、线程的创建：

a）继承Thread类，并重写run（）方法。

然后newThread（）.start;

开启线程。

b）实现Runnable接口，重写run（）方法。

然后newThread（newmyRunnable）.start开启线程。

37、两种实现多线程的比较——实现Runnable接口的方法更好

a）可以让多个线程共享资源。

——售票系统需要。

b）避免单继承。

38、

36、