CoreJava总结.docx

CoreJava总结.docx

《CoreJava总结.docx》由会员分享，可在线阅读，更多相关《CoreJava总结.docx（77页珍藏版）》请在冰豆网上搜索。

CoreJava总结

Java概述

一、JDK/JRE/JVM

JDK：

JAVA开发工具包，比JRE多了一些开发和调试的命令，比如javac、java等等。

JRE：

JAVA运行环境

JVM：

JAVA虚拟机

包含关系：

JDK包含JRE，JRE包含JVM

三、配置环境变量

JAVA_HOME：

JDK的安装路径

CLASSPATH：

类的搜索路径

PATH：

命令的搜索路径

--右键我的计算机-->高级-->环境变量-->在系统变量或者用户变量上配置-->

JAVA_HOME：

当前机器上JDK的文件目录"C:

\ProgramFiles\Java\jdk1.6.0_05"

CLASSPATH：

类的搜索路径"."当前目录

Path:

命令的搜索路径...;%JAVA_HOME%\bin

--开始-->运行-->cmd-->java验证是否配置成功

二、注释

三种：

1、单行注释:

//...

2、多行注释:

/*...*/

3、文檔注释:

/**......*/另一种多行注释，但是这种注释可以生成API文檔（HTML格式的）

提取API文檔的命令：

javadoc

javadoc应用，提取说明文件

javadocXX.java-d生成文文件路径

比如：

javadocString.java-d.\stringdoc

在String.java所在的檔夹中便会生成一个stringdoc檔夹，里面是html格式的解释文檔

顺便教下学生看API文檔

三、标识符

只能以字母,“_”,“$”符号开头，不能以数位开头支持汉字

四、良好的编码习惯

1、类的首字母要大写，如果有多个单词，每个单词首字母都要大写比如：

HelloWorld

2、接口名命名与类名一样

3、方法名第一个单词小写，以后每个单词的首字母都大写比如：

getName

4、变量名的命名习惯和方法名的相同

5、常量（不可改变的）的名字所有字母都大写，单词与单词之间用“_”连接比如：

DRIVER_NAME

6、包名所有字母都小写

三、关键词（50个）

自己命名变量名或者其它名字不能和关键词的一样

true，false，null不是关键词，是字面值，同样不能把这些单词作为名字

goto和const是保留字，并不应用于java开发，也不能作为其它名字使用

其它语言中goto语句的用法（无条件跳转）

java中的代替goto的是breakloop;loop是个标号，标记一个循环，breakloop就结束了这个循环

数据类型和控制结构

一、数据类型

boolean两个值true或者false，占8个二进制位

byte8位整数

short16位整数

char16位的Unicode编码，有足够的空间保存非英文字符

--'A':

65,'a':

97,'0':

48

int32位整数

long64位整数

float32位浮点型

double64位浮点型

二、String类型：

是一个类，而不是基本类型

赋值的话就用双引号引起来，比如Stringa="abc";

三、整型数据

整型变数赋值

intia=0x55;//这种赋值是可以的，赋值为了一个16进制资料

bytebb=0x771;//0x771已经超出了byte的取值范围，所以编译这句话会出错

byteba=（byte）0x771;//把0x771强制转换成byte

longla=1234567L;//给long类型的变量赋值

四、浮点型数据

1、赋值

floatfa=123.4F//后面加个F

doubled=123.456D//后面的D跟不跟都可以

类型转换：

自动类型转换

小范围---大范围

Byte-short-int-long-float-double

Char-int

在表数范围内的常数可以自动转换

强制类型转换

五、垃圾回收

1、如果某一个对象没有引用指向它了，那么这个对象就是个垃圾对象

比如Strings=newString（"..."）;

s=null;

那被new出来的String对象就是一个垃圾数据了

2、垃圾回收机制

对于没有被引用的对象，javaJVM会自动回收

System.gc（）提醒虚拟机进行垃圾回收，但只是提醒建议

break和continue后面可以加下标，跳出循环和继续循环。

四、for循环

--语法

for（1;2;3）{

...

}

五、while循环

--语法

while（boolean）{

...

}

--每循环一次就判断括号中的代码是不是为真，是真的话就继续循环，假的话就结束循环

六、do..while循环

--语法

do{

...

}while（boolean）;

--无论如何都会先执行一次再判断条件是否为真，其它的和while循环规则一样

数组

一、数组

二维数组

1、声明二维数组

语法：

--int[][]ia;

2、实例化

语法：

--int[][]ia=newint[3][5];

3、声明时赋值

4、不规则数组，也就是每一行数组的长度不一样

a[0]=newint[5];

a[1]=newint[3];

a[2]=newint[4];那么这样这个数组就成为了一个第一行长度是5，第二行长度是3，第三行长度是4的不规则二维数组

面向对象

二、类

1、创建类的语法：

publicclass类名{

类型变量名;

类型变量名;

例子：

publicclassAnimal{

Stringname;

intage;

...

publicvoideat（）{

...

}

publicvoidmove（）{

...

}

...

}

2、创建类的对象的语法：

类名对象名=new类名（）;

Animala=newAnimal（）;

调用对象的成员

对象名.属性名;

对象名.方法名（）;

a.name=...;

a.move（）;

3、构造方法：

用处：

1、构造方法一般用来为属性赋初值

2、构造方法会在生成对象时被系统自动调用

特点：

1、没有返回值，写返回值的位置什么都不写

2、方法名必须和类名完全相同

4、this的用法

this等价于当前对象，调用当前对象的属性或方法就用this.属性名，或this.方法名（）。

5、访问控制修饰符：

public：

公共的，如果用这个修饰属性和方法，则这个属性和方法能在任何地方被调用。

private：

私有的，如果用这个修饰属性和方法，则这个属性和方法只能在类的内部被使用。

修饰符的作用：

封装类

6、封装：

如果一个数据类型，把它不想让外部知道的属性和方法私有化，把它能让外部访问的属性和方法公共化，这就叫封装。

封装的好处：

代码维护方便，如果属性名变了，其它程序根本不用做改动，还是调用这个控制属性的方法就行了

7、方法的重载：

一个类中同名但参数不同的方法

this（..,..）;调用本类其它的构造方法

this（..,..）这样的调用只能出现在构造方法的第一行

类的加载过程、实例化、继承、多态

Java类的加载过程：

类的加载过程：

A.new一个对象的时候-------加载

B.没有创建对象，访问类中静态成员（方法和属性）-------加载

C.声明一个类的引用-------不载入

D.创建子类，先载入父类，再载入子类

E.父类中的公开静态方法，子类继承，使用子类的类名调用此方法，只加载父类

classSuper{

publicstaticm（）{}

}

classSubextendsSuper{}

在主函数中运行以下代码：

Sub.m（）;//加载了父类之后，虚拟机已经知道m（）方法的调用了，就不会再加载子类

对象实例化过程：

1.类加载，执行静态语句块和静态的属性赋值（先父类后子类）

2.预开空间，所有属性设零值

3.实例化对象：

（先父类后子类）

1）初始化所有的属性，和非静态语句块（自上而下执行）

2）构造函数

类加载的顺序:

[具体顺序是：

先加载父类的static代码块，再加载子类的static代码块；

再加载父类的代码块，再调用父类的构造方法；

在加载子类的代码块，再调用子类的构造方法。

］

继承（代码重用）

1、语法-->publicclass子类名extends父类名{...}

2、子类的对象可以调用父类的一切公有的变量和方法，也可以扩展自己新的属性和方法，但是新扩展的部分父类的对象是无法调用的

3、super（..,..）的用法，在子类的构造方法中调用父类的构造方法，并且super要放在第一行，不能与this一起用

主要用为在构造子类的时候给父类中定义的变量赋值

4、子类的一些特点

--任何子类的构造方法都会调用父类的构造方法

--任何子类的构造方法的第一行必须是this（..,..）或super（..,..）的调用，如果程序员不写，则系统会隐含的调用super（）

也就是说，子类不管怎样一定会调用父类的构造方法

方法覆盖的原则：

--发生在父子类之间

--同名，同参，同返回类型（可以返回子类型）

--子类的方法的修饰符不能比父类方法的修饰符更封闭，比方说父类的是public，子类的就不能为private

--抛出异常类型不能更宽泛

三、多态

1、方法的重载和覆盖就是方法多态的一种体现

2、对象的多态，一个对象多种形态，这要取决于对象的继承关系

表现对象多态的一种形式，把子类对象当作父类对象的一种形式：

父类名对象名=new子类名（）;-->Animala=newBird（）;

但是这样的话，此对象不能调用父类中没有的方法

3、多态定理：

--如果我们把子类对象当作父类对象来看，那么就只能访问父类中已有定义的属性和方法（不能访问子类扩展的属性和方法）

--如果子类覆盖了父类的方法，再把子类对象当作父类对象去调用该方法时，调用的是子类覆盖后的方法。

4、instanceof，判断一个对象是不是某一个类型的实例，用法

对象名instanceof类名;返回一个布尔值，如果前者是后者的实例则返回真

一般这样用：

Animala=newBird（）;

//如果a是Bird的实例，做什么

if（ainstanceofBird）{

Birdb1=（Bird）a;

a.sing（）;

}

并不是所有的父类都能转换成子类

如果任意强转不匹配的类型就会抛出java.lang.ClassCastException

类型转换异常：

把一个原本不是这种类型的对象强转成这种对象

所以在强转之前最好用instanceof做一下判断，如果是这种类型的实例再强转

修饰符

一、修饰符

1、static

描述整体特征而不是个体特征的属性时，用静态修饰符

--静态和非静态的差别

1、空间分配时机：

静态变量是在类加载的时候分配空间，非静态对象是在生成对象的时候分配空间

2、空间分配方式：

不管有多少对象静态变量只有一份（所有对象共享），非静态变量有多少对象就分配多少个空间

3、访问方式：

静态变量是：

类名.属性，比如Animal.COUNT

非静态变量：

对象名.属性，比如a.name

--静态方法和非静态方法的区别

1、静态方法是通过类名来调用，非静态方法是通过对象来调用

2、静态方法中不能访问本类的非静态成员，但非静态方法可以访问静态成员

为什么主方法非要是静态的：

我们看执行javaTest命令后的运行步骤

1、启动JVM

2、找到Test.class

3、载入Test.class

4、Test.main（）;

--静态代码块

1、静态代码块会在类被加载时被系统自动执行

2、一般可以在静态代码块中给静态属性赋值

静态方法不存在多态特性，也就是静态方法无法被子类覆盖，父类对象调用此方法还是父类的，类的静态代码块只能有一个。

静态方法可以覆盖，但没有多态，属性也一样。

静态方法只属于本类，并且不能被子类的同名同参的静态方法覆盖。

属性也一样，可以被覆盖但没有多态，子类定义相同的属性，该属性仍然用原来本类对象的属性值。

（这里叫覆盖不合适）

其调用按多态用法：

只有非静态方法有多态；而静态方法、静态属性、非静态属性都没有多态。

2、final

1、修饰属性：

属性不可变，并且属性在声明的时候必须初始化，或者在构造方法中初始化一般与static一起用，一旦定义了，就不能再变了。

两种赋值方式有不同之处，声明的时候初始化所有类的对象的常量都一样，所以一般用staticfinal声明。

构造方法中声明，表示类的每个对象的常量可以是不一样的。

2、修饰方法：

方法不能被覆盖

3、修饰类：

类不能被继承

4、修饰局部变数：

局部变量不可变（常量）

3、abstract（抽象）

1、用来修饰类和方法。

2、修饰类的话表示这个类是个抽象类，抽象类不能被实例化（生成对象）。

3、修饰方法的话表示这个方法是个抽象方法，抽象方法没有方法体。

4、如果一个类包含有一个抽象方法，那么这个类必须是抽象类。

5、如果一个类不包含抽象方法，那么该类也可以被定义成抽象类。

6、抽象类不能被实例化，但却可以定义引用。

7、抽象类一般需要实现--定义一个子类，并实现抽象方法。

8、抽象类也是有构造方法的，因为需要被子类调用。

9、子类必须实现父类的抽象方法。

--abstract和final不能共同修饰一个类或方法

二、接口terface

1、是一种抽象的数据类型，特殊的抽象类。

2、接口中的所有方法都是抽象方法。

3、接口中所有的属性都是finalstatic的（静态常量）。

4、接口也不能被实例化，但可以定义的接口的引用。

5、接口没有构造方法。

6、一个类只能继承一个父类，但是可以实现多个接口，用逗号隔开。

7、接口之间可以多继承。

接口与类的关系和区别

子父

类extends类（单一）

类implements接口（多重）

接口extends接口（多重）

implements实现

abstract可以省略不写的，因为interface本身就是抽象的

高级语言特征

第六章、高级语言特性

1、访问控制修饰符

本类同包子类其它类

publicYESYESYESYES

protectedYESYESYESNO（所定义的成员受包和继承结构的保护）

不写修饰符YESYESNONO

privateYESNONONO

staticfinalabstractpublicprotecteddefaultprivate

顶层类NYYYNYN

属性YYNYNYY

方法YYYYYYY

局部变数NYNNNNN

（protected是可以定义属性的）

2、java.lang.Object类

这个方法是让子类覆盖的，但子类也必须同是实现java.lang.Cloneable接口

对象克隆过程：

1、要让这个类实现Cloneable接口

2、要覆盖Object中的clone（）方法

深拷贝和浅拷贝：

浅拷贝只是把当前对象拷贝了，但是当前对象中有存在对别的对象的引用的属性，那么那个属性还是指向同一个对象。

所以如果直接调用clone（）方法的话就属于浅拷贝。

如果这个类里只有字符串对象和基本数据类型，那么也属于深拷贝。

finalize（）:

垃圾回收器调用

equals（Objectobj）:

判断两个对象是否相等

--反身性：

对任意非空的值调用此方法自己和自己比应该返回真

--对称性：

对任意非空的引用值x和y，如果x.equals（y）返回真，那么反之亦然

--传递性：

x，y，z，x.equals（y）返回真，x.equals（z）返回真，z.equals（y）也应返回真

--一致性：

结果应为确定的，如果对象不变，无论调用多少此都返回相同结果

--对于任意非空的引用值和空比较都应返回假

toString（）：

输出对象时输出这个方法的返回值

System.out.println（）;方法输出的对象和对象的toString（）方法，的结果是一样的。

也就是说输出一个对象的时候，系统会自动调用toString（）方法。

如：

Students=newStudent（…）;

System.out.println（s）;

System.out.println（s.toString（））;

Stringstr=”Hello”+s;

3、java.lang.String类

如果Strings1="hello"这样直接赋值的话，那么与同样直接赋值的比较如果字符串相等的话就相等。

如果和Strings3=newString（"hello"）;这样的对象比较的话如果字符串相同才返回假

java.lang.StringBuffer线程安全

java.lang.StringBuilder线程不安全

--以上这两个类如果对字符串做修改的话不会创建新对象，只是在原来对象基础上改

主方法，静态导入，包装类，枚举

1、对象池

一般我们获得一个类的对象都是通过new的形式，如果不用这种形式的话我们就可以写一个获取对象的方法来获取对象。

原理：

我们生成对象以后便把此对象保存到对象池中，这样我们用完了此对象也不会被释放，以后我们再用到此对象的时候就直接在对象池里取就行了。

我们可以先在类中创建一个此类对象的数组，要声明成静态的。

然后在此类中写一个获得对象的静态方法，一定要是静态的，不然获得对象的方法就没有什么意义了。

2、包装类

针对八种基本类型的包装类，在基本类型和对象类型之间建立桥梁，使基本数据类型也可以当作对象来用

基本数据类型包装类

booleanBoolean

byteByte

shortShort

charCharacter

intInteger

longLong

floatFloat

doubleDouble

内部类

一、内部类innerclass

为的是隐藏一种数据类型，这种数据类型只在一个类中可见。

就像生物圈中的寄居、寄生。

四种形式的内部类：

静态内部类--

|-成员式的（存在于类体中）

成员内部类--

局部内部类--

|-局部式的

匿名内部类--

内部类的修饰符：

staticfinalabstractpublicprotecteddefaultprivate

顶层类NYYYNYN

属性YYNYNYY

方法YYYYYYY

局部变数NYNNNNN

成员式内部类YYYYYYY

局部式内部类NYYNNNN

局部变量和局部类（在方法体中）只能使用final，局部类类多一个abstract，其它的修饰符都是不可以的。

内部类可以访问外部类的私有成员。

如果要访问内部类的话

1、静态内部类：

静态内部类：

作为一个类成员存在

修饰符和成员内部类相同publicprotected（Default）privateabstractfinalstatic

不能访问外部类的非静态成员，可以访问静态成员

实例化（new外部类名.内部类构造函数（））

声明（外部类名.内部类名变数）

静态内部类里可以定义静态的属性和方法

2、成员内部类：

成员内部类：

作为一个对象（实例）的成员存在

修饰符可以是publicprotected（Default）privateabstractfinalstatic

可以访问外部类的成员（外部类名.this.成员）

实例化（外部类对象的引用.new内部类构造函数（））

声明（外部类名.内部类名变数）

成员内部类里不能定义静态的属性和方法

3、局部内部类

局部内部类：

定义在方法体里的类

修饰符可以是abstractfinal

可以访问外部类的成员

声明和实例化跟普通类一样

局部内部类里不能定义静态的属性和方法

局部内部类只能访问final修饰的局部变数

4、匿名内部类

匿名内部类：

没有类名的类

可以访问外部类的成员

声明和实例化一起（声明类型变量=new声明类型（）{类的定义}）；

声明类型：

抽象类接口普通类

匿名内部类如果定义在方法体里，则具有和局部内部类相同的特征

匿名内部类可以定义在属性的赋值上

集合List

List列表

--有序存放（放在List中的每一个元素都是有顺序的，有自己的位置的），允许重复（可以存放相同的元素），List可用get。

而Set则不可用（因其无序）。

--实现类：

ArrayList：

底层数数组实现的，实现了数组的变长，初始的数组容量默认是10。

LinkedList：

实现了队列的接口，底层是链表实现的，先进先出。

Set集合（和数学上集合的概念相似）

--无序存放，不允许重复。

--子接口：

SortedSet排序集合

--实现类：

TreeSet

--实现类：

HashSet

Queue队列（先进先出）

--父接口，Iterable，可迭代的，凡是实现这个接口的实现类对象都可以用迭代的方式去循环访问

--iterator（）方法，调用此方法可以得到一个迭代器Iterator

--父接口，Iterator迭代器

--hasNext（）方法，是否还有下个元素

--next（）,表示下个元素

--remove（）,移除当前跌带到的对象

定义：

跟数组一样，可以存放多个数据。

提供了一些辅助的方法。

分类：

Collection:

集合大接口，List和Set都是他的子接口

List:

排序的，可以重复的

ArrayList:

数组实现，遍历快，增加删除效率低

LinkedList：

链表实现，遍历较慢，增加删除效率高

Vector：

数组实现，同步的，线程安全，重量级的。

（牺牲了效率，提高数据的安全性）

Set：

不排序，不可重复

HashSet:

数组和链表实现的。

不排序的

不能重复的（hashCode相同，则覆盖）

TreeS