java各知识点详细总结

Java知识

第1章

一、java概述

1、java发展：

1991 年Sun公司的James Gosling等人开始开发名称为Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器；

1994年将Oak语言更名为Java；

2、Java的三种技术架构:

JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发；

JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发，是其它两者的基础；

JAVAME：Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的程序；

3、JDK：Java Development Kit，java的开发和运行环境，java的开发工具集和jre。

4、JRE：Java Runtime Environment，java程序的运行环境，java运行的所需的类库+JVM(java虚拟

机)。

5、配置环境变量：

Path: 操作系统外部命令搜索路径

Classpath: 类文件搜索路径“.”表当前目录

6、javac命令和java命令

要知道java是分两部分的：一个是编译，一个是运行。

javac：负责的是编译的部分，当执行javac时，会启动java的编译器程序。对指定扩展名的.java 文件进行编译,生成了jvm可以识别的字节码文件,也就是class文件，也就是java的运行程序。

java：负责运行的部分.会启动jvm.加载运行时所需的类库,并对class文件进行执行。

一个文件要被执行,必须要有一个执行的起始点,这个起始点就是main方法.

7、虚拟机

当我们在虚拟机中进行软件评测时，可能系统一样会崩溃，但是，崩溃的只是虚拟机上的操作系统，而不是物理计算机上的操作系统，并且，使用虚拟机的“Undo”（恢复）功能，可以马上恢复虚拟机到安装软件之前的状态。

8、public class和class

● public class：文件名称和类名称一致，一个*.java文件之中只能够存在一个public class定义。ava 文件之中可以同时存在多个class定义，并且编译之后会形成不同的*.class文件。

第2章java语法基础

1、关键字：某种语言赋予了特殊含义的单词。

保留字：还没有赋予特殊含义，但是准备日后要使用的单词。

2、标示符：就是在程序中自定义的名词。比如类名，变量名，方法名。包含0-9、a-z、$、_ ；

注意：1）数字不可以开头。2）不可以使用关键字。

3、常量：是在程序中不会变化的数据。

4、变量：其实就是内存中的一个存储空间，用于存储数据。

作用：方便运算。因为有些数据不确定，所以确定该数据的名字和存储空间。

特点：变量空间可以重复使用。

什么时候定义变量只要是数据不确定的时候，就定义变量。

变量空间的开辟需要什么要素呢

（1）数据类型。（2）变量名称。（3）变量的初始化值。

变量的作用域和生存期:

变量的作用域：

作用域从变量定义的位置开始，到该变量所在的那对大括号结束；

生命周期：

变量从定义的位置开始就在内存中有生命了；

变量到达它所在的作用域的时候就在内存中消失了；

5、数据类型：

1）基本数据类型：byte、short、int、long、float、double、char、boolean

2）引用数据类型: 数组、类、接口。

级别从低到高为：byte,char,short(这三个平级)-->int-->float-->long-->double

自动类型转换：从低级别到高级别，系统自动转换；

强制类型转换：什么情况下使用把一个高级别的数赋给一个比该数的级别低的变量；

格式：类型变量名=（类型）表达式；

例：int a=(int)100L;

6、运算符号：

1）算术运算符。

+ - * / % %:任何整数模2不是0就是1，所以只要改变被模数就可以实现开关运算。

+:连接符。

++,--

2）赋值运算符。

= += -= *= /= %=

3）比较运算符。

特点：该运算符的特点是：运算完的结果，要么是true，要么是false。

4）逻辑运算符。

& | ^ ! && ||

逻辑运算符除了! 外都是用于连接两个boolean类型表达式。

&: 只有两边都为true结果是true。否则就是false。

|:只要两边都为false结果是false，否则就是true

^:异或：两边结果一样，就为false。两边结果不一样，就为true.

& 和&&区别：& ：无论左边结果是什么，右边都参与运算。

&&:短路与，如果左边为false，那么右边不参数与运算。

| 和|| 区别：|：两边都运算。

||：短路或，如果左边为true，那么右边不参与运算。

5）位运算符:用于操作二进制位的运算符。

& | ^

<< >> >>>(无符号右移)

7、语句

If switch do while while for

1）当判断固定个数的值的时候，可以使用if，也可以使用switch。但是建议使用switch，效率相对较高。.}；

元素类型[] 变量名= new 元素类型[]{元素1，元素2...}；

第3章面向对象

一、在类中的定义都称之为成员。成员有两种：

1、成员属性：对应的就是事物的属性。

2、成员方法：对应的就是事物的行为。

必须先要对事物进行属性和行为的分析，才可以用代码来体现。

注意：主方法的存在，仅为该类是否需要独立运行，如果不需要，主方法是不用定义的。

主方法的解释：保证所在类的独立运行，是程序的入口，被jvm调用。

成员属性和局部变量的区别：

1、成员属性直接定义在类中。

局部变量定义在方法中，参数上，语句中。

2、成员属性在这个类中有效。

局部变量只在自己所属的大括号内有效，大括号结束，局部变量失去作用域。

3、成员属性存在于堆内存中，随着对象的产生而存在，消失而消失。

局部变量存在于栈内存中，随着所属区域的运行而存在，结束而释放。

二、构造方法：用于给对象进行初始化，是给与之对应的对象进行初始化，它具有针对性，方法

中的一种。

特点：

1、该方法的名称和所在类的名称相同。

2、不需要定义返回值类型。

3、该方法没有具体的返回值。

记住：所有对象创建时，都需要初始化才可以使用。

注意事项：一个类在定义时，如果没有定义过构造方法，那么该类中会自动生成一个空参数的构造方法，为了方便该类创建对象，完成初始化。如果在类中自定义了构造方法，那么默认的构造方法就没有了。

一个类中，可以有多个构造方法，因为它们的方法名称都相同，所以只能通过参数列表来区分。所以，一个类中如果出现多个构造方法。它们的存在是以重载体现的。

构造方法和一般方法有什么区别呢

1、两个方法定义格式不同。

2、构造方法是在对象创建时，就被调用，用于初始化，而且初始化动作只执行一次。调用的是成员属性和成员方法(一般方法)；

this对象后面跟上() 调用的是本类中的对应参数的构造方法。

注意：用this调用构造方法，必须定义在构造方法的第一行。因为构造方法是用于初始化的，所以初始化动作一定要执行。否则编译失败。

五、static：关键字，是一个修饰符，用于修饰成员(成员属性和成员方法)。

特点：

1、想要实现对象中的共性数据共享。可以将这个数据进行静态修饰。

2、被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。课();

电影(); A11 y = (A11)x;

y.看电影();名

编译命令：javac –d 位置（.当前路径）java源文件（就可以自动生成包）

包是一种封装形式，用于封装类，想要被包以外的程序访问，该类必须为public；

类中的成员，如果被包以外访问，也必须public；

包与包之间访问可以使用的权限有两种：

1、public

2、protected：只能是不同包中的子类可以使用的权限。

总结java中的四种权限：

范围public protected default private

同一个类中ok ok ok ok

同一包中ok ok ok

子类ok

不同包中ok

-----------------------------------------------------------------------------------------------

Import - 导入：类名称变长，写起来很麻烦。为了简化，使用了一个关键字：import，可以使用这个关键字导入指定包中的类。记住：实际开发时,到的哪个类就导入哪个类，不建议使用*.

import packa.*;;ar 包目录

解压缩：jar –xvf 包名.jar

将jar包目录列表重定向到一个文件中：jar –tf 包名.jar >c:\

和import .*的形式的小技巧。

-----------------------------------------------------------------------------------------------

第4章

一、异常：★★★★

异常：就是不正常。程序在运行时出现的不正常情况。其实就是程序中出现的问题。这个问题按照面向对象思想进行描述，并封装成了对象。因为问题的产生有产生的原因、有问题的名称、有问题的描述等多个属性信息存在。当出现多属性信息最方便的方式就是将这些信息进行封装。异常就是java按照面向对象的思想将问题进行对象封装。这样就方便于操作问题以及处理问题。

出现的问题有很多种，比如角标越界，空指针等都是。就对这些问题进行分类。而且这些问题都有共性内容比如：每一个问题都有名称，同时还有问题描述的信息，问题出现的位置，所以可以不断的向上抽取。形成了异常体系。

：

Throwable：可抛出的。

|--Error：错误，一般情况下，不编写针对性的代码进行处理，通常是jvm发生的，需要对程序进行修正。

|--Exception：异常，可以有针对性的处理方式。

无论是错误还是异常，它们都有具体的子类体现每一个问题，它们的子类都有一个共性，就是都以父类名作为子类的后缀名。

这个体系中的所有类和对象都具备一个独有的特点；就是可抛性。

可抛性的体现：就是这个体系中的类和对象都可以被throws和throw两个关键字所操作。

------------------------------------------------------

class ExceptionDemo{

public static void main(String[] args) {

.

这样标示后，调用者，在使用该功能时，就必须要处理，否则编译失败。

处理方式有两种：1、捕捉；2、抛出。

对于捕捉：java有针对性的语句块进行处理。

try {

需要被检测的代码；

}

catch(异常类 变量名){

异常处理代码；

}

fianlly{

一定会执行的代码；

} --------------------------------------------------------

catch (Exception e) { etName() + '@' + (hashCode()) 为了对象对应的字符串内容有意义，可以通过复写，建立该类对象自己特有的字符串表现形式。 public String toString(){ return "person : "+age;

}

3、Class getClass ()：获取任意对象运行时的所属字节码文件对象。

4、int hashCode ()：返回该对象的哈希码值。支持此方法是为了提高哈希表的性能。将该对象的内部地址转换成一个整数来实现的。

通常equals ，toString ，hashCode ，在应用中都会被覆写，建立具体对象的特有的内容。 ------------------------------------------------------------------------------------------------

--< >-- String 字符串

java 中用String 类进行描述。对字符串进行了对象的封装。这样的好处是可以对字符串这种常见数据进行方便的操作。对象封装后，可以定义N 多属性和行为。

如何定义字符串对象呢String s = "abc";只要是双引号引起的数据都是字符串对象。

特点：字符串一旦被初始化，就不可以被改变，存放在方法区中的常量池中。

------------------------------------------------------

String s1 = "abc"; String substring(int start,int end);法名:不用建立对象，直接类名调用；

将基本类型转成字符串：Integer 中的静态方法 String toString(int);

将一个十进制整数转成其他进制：

转成二进制：toBinaryString

转成八进制：toOctalString

转成十六进制：toHexString

toString(int num,int radix);

将其他进制转换十进制：

parseInt(string,radix);

2, try catch 3, try finally

Map集合存储和Collection有着很大不同：

Collection一次存一个元素；Map一次存一对元素。

Collection是单列集合；Map是双列集合。

Map中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系。

特点：要保证map集合中键的唯一性。

1、添加。

put(key,value)：当存储的键相同时，新的值会替换老的值，并将老值返回。如果键没有重复，返回null。

void putAll(Map);

2、删除。

void clear()：清空

value remove(key) ：删除指定键。

3、判断。

boolean isEmpty()：

boolean containsKey(key)：是否包含key

boolean containsValue(value) ：是否包含value

4、取出。

int size()：返回长度

value get(key) ：通过指定键获取对应的值。如果返回null，可以判断该键不存在。当然有特殊情况，就是在hashmap集合中，是可以存储null键null值的。

Collection values()：获取map集合中的所有的值。

5、想要获取map中的所有元素：

原理：map中是没有迭代器的，collection具备迭代器，只要将map集合转成Set集合，可以使用迭代器了。之所以转成set，是因为map集合具备着键的唯一性，其实set集合就来自于map，set集合底层其实用的就是map的方法。

★把map集合转成set的方法：

Set keySet();

Set entrySet();Calendar：日历类

public static void method(){

Calendar c = ();

"年"++1)+"月"

+getNum)+"日"

+"星期"+getWeek));

}

public static String getNum(int num){

return num>9 num+"" : "0"+num;

}

public static String getWeek(int index){

/*

查表法：建立数据的对应关系.

最好：数据个数是确定的，而且有对应关系。如果对应关系的一方，是数字，而且可以作为角标，那么可以通过数组来作为表。

*/

String[] weeks = {"","日","一","二","三","四","五","六"};

return weeks[index];

}

------------------------------------------------------------------------------------------------------------------------------------------------

第六章IO流

流：可以理解数据的流动，就是一个数据流。

IO用于处理设备上数据。在流中一般以字节的形式存放着数据。

IO流最终要以对象来体现，对象都存在IO包中。IO异常的处理方式：IO一定要写finally；

流的分类：

1、输入流（读）和输出流（写）。

2、因为处理的数据不同，分为字节流和字符流。

字节流：处理字节数据的流对象。设备上的数据无论是图片或者dvd，文字，它们都以二进制存储的。二进制的最终都是以一个8位为数据单元进行体现，所以计算机中的最小数据单元就是字节。意味着，字节流可以处理设备上的所有数据，所以字节流一样可以处理字符数据。

为什么要有字符流呢因为字符每个国家都不一样，所以涉及到了字符编码问题，那么GBK编码的中文用unicode编码解析是有问题的，所以需要获取中文字节数据的同时也指定的编码表才可以解析正确数据。为了方便于文字的解析，所以将字节流和编码表封装成对象，这个对象就是字符流。只要操作字符数据，优先考虑使用字符流体系。

注意：流的操作只有两种：读和写。

流的体系因为功能不同，但是有共性内容，不断抽取，形成继承体系。该体系一共有四个基类，而且都是抽象类。即：

字节流：InputStream OutputStream

字符流：Reader Writer

在这四个系统中，它们的子类，都有一个共性特点：子类名后缀都是父类名，前缀名都是这个子类的功能名称。

流对象：其实很简单，就是读取和写入。但是因为功能的不同，流的体系中提供N多的对象。那么开始时，到底该用哪个对象更为合适呢这就需要明确流的操作规律。

流的操作规律：

1，明确源和目的。

数据读取：InputStream、Reader；

数据写入：OutputStream、Writer；

2，操作的数据是否是纯文本数据

如果是：数据读取：Reader

数据写入：Writer

如果不是：数据读取：InputStream

数据写入：OutputStream

3，虽然确定了一个体系，但是该体系中有太多的对象，到底用哪个呢

明确操作的数据设备。

数据输入对应的设备：硬盘(File)，内存(数组)，键盘

数据输出对应的设备：硬盘(File)，内存(数组)，控制台。

--------------------------------------------------------------------------------------------------------------------

字符流：

Reader：用于读取字符流的抽象类。子类必须实现的方法只有read(char[], int, int) 和close()。

|---BufferedReader：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

|---LineNumberReader：跟踪行号的缓冲字符输入流。此类定义了方法setLineNumber(int) 和getLineNumber()，它们可分别用于设置和获取当前行号。

|---InputStreamReader：是字节流通向字符流的桥梁：它使用指定的charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

|---FileReader：用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在FileInputStream 上构造一个InputStreamReader。

|---CharArrayReader：

|---StringReader：

-------------------------------------------------

Writer：写入字符流的抽象类。子类必须实现的方法仅有write(char[], int, int)、flush() 和close()。

|---BufferedWriter：将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字

符串的高效写入。

|---OutputStreamWriter：是字符流通向字节流的桥梁：可使用指定的charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

|---FileWriter：用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。要自己指定这些值，可以先在FileOutputStream 上构造一个OutputStreamWriter。

|---PrintWriter：

|---CharArrayWriter：

|---StringWriter：

---------------------------------

字节流：

InputStream：是表示字节输入流的所有类的超类。

|--- FileInputStream：从文件系统中的某个文件中获得输入字节。哪些文件可用取决于主机环境。FileInputStream 用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用FileReader。

|---FilterInputStream：包含其他一些输入流，它将这些流用作其基本数据源，它可以直接传输数据或提供一些额外的功能。

|--- BufferedInputStream：该类实现缓冲的输入流。

|--- Stream：

-----------------------------------------------

OutputStream：此抽象类是表示输出字节流的所有类的超类。

|---FileOutputStream：文件输出流是用于将数据写入File 或FileDescriptor 的输出流。

|---FilterOutputStream：此类是过滤输出流的所有类的超类。

|---BufferedOutputStream：该类实现缓冲的输出流。

|--- PrintStream：

|--- DataOutputStream：

--------------------------------

缓冲区是提高效率用的，给谁提高呢

BufferedWriter(将流和缓冲区结合)：是给字符输出流提高效率用的，那就意味着，缓冲区对象建立时，必须要先有流对象。明确要提高具体的流对象的效率。

FileWriter fw = new FileWriter("");

BufferedWriter bufw = new BufferedWriter(fw);quals(line))

break;

()); long length()：获取文件大小。

String getName()：返回由此抽象路径名表示的文件或目录的名称。

String getPath()：将此抽象路径名转换为一个路径名字符串。

String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串。

String getParent()：返回此抽象路径名父目录的抽象路径名，如果此路径名没有指定父目录，则返回null。

long lastModified()：返回此抽象路径名表示的文件最后一次被修改的时间。

：返回当前系统默认的路径分隔符，windows默认为“；”。

：返回当前系统默认的目录分隔符，windows默认为“\”。

4、判断：

boolean exists()：判断文件或者文件夹是否存在。

boolean isDirectory()：测试此抽象路径名表示的文件是否是一个目录。

boolean isFile()：测试此抽象路径名表示的文件是否是一个标准文件。

boolean isHidden()：测试此抽象路径名指定的文件是否是一个隐藏文件。

boolean isAbsolute()：测试此抽象路径名是否为绝对路径名。

5、重命名。

boolean renameTo(File dest)：可以实现移动的效果。剪切+重命名。

String[] list()：列出指定目录下的当前的文件和文件夹的名称。包含隐藏文件。

如果调用list方法的File 对象中封装的是一个文件，那么list方法返回数组为null。如果封装的对象不存在也会返回null。只有封装的对象存在并且是文件夹时，这个list()方法才有效。

------------------------------------------------------------------------------------------------

递归：就是方法自身调用自身。

什么时候用递归呢

当一个功能被重复使用，而每一次使用该功能时的参数不确定，都由上次的功能元素结果来确定。

简单说：功能内部又用到该功能，但是传递的参数值不确定。(每次功能参与运算的未知内容不确定)。

递归的注意事项：

1、一定要定义递归的条件。

2、递归的次数不要过多。容易出现StackOverflowError 栈内存溢出错误。

其实递归就是在栈内存中不断的加载同一个方法。

FileWriter写入数据的细节：

public static void main(String[] args) {

FileWriter fw = null;

try {

fw = new FileWriter("",true);

("abcde");

}

catch (IOException e ){

"....");

}

finally{

if(fw!=null)

try{

();

}

catch (IOException e){

"close:"+());

}

}

}

--------------------------------------------------------------------------------------------------------------------FileReader：使用Reader体系，读取一个文本文件中的数据。返回-1 ，标志读到结尾。

例1：

import .*;

class FileReaderDemo {

public static void main(String[] args) throws IOException {

/*

创建可以读取文本文件的流对象，FileReader让创建好的流对象和指定的文件相关联。

*/

FileReader fr = new FileReader("");

int ch = 0;

while((ch = ())!= -1) { ;

class FileReaderDemo2 {

public static void main(String[] args) throws IOException {

FileReader fr = new FileReader("");

4、该流的print方法不抛出IOException。

该对象的构造方法。

PrintStream(File file) ：创建具有指定文件且不带自动行刷新的新打印流。

PrintStream(File file, String csn) ：创建具有指定文件名称和字符集且不带自动行刷新的新打印流。PrintStream(OutputStream out) ：创建新的打印流。

PrintStream(OutputStream out, boolean autoFlush) ：创建新的打印流。

PrintStream(OutputStream out, boolean autoFlush, String encoding) ：创建新的打印流。PrintStream(String fileName) ：创建具有指定文件名称且不带自动行刷新的新打印流。PrintStream(String fileName, String csn)

PrintStream可以操作的目的地：1：File对象。2：字符串路径。3：字节输出流。

前两个都版本才出现。而且在操作文本文件时，可指定字符编码了。

当目的是一个字节输出流时，如果使用的println方法，可以在printStream对象上加入一个true 参数。这样对于println方法可以进行自动的刷新，而不是等待缓冲区满了再刷新。最终print方法都将具体的数据转成字符串，而且都对IO异常进行了内部处理。

既然操作的数据都转成了字符串，那么使用PrintWriter更好一些。因为PrintWrite是字符流的子类，可以直接操作字符数据，同时也可以指定具体的编码。

BufferedReader bufr = new BufferedReader(new InputStreamReader);quals(line))

break;

());;

class ObjectStreamDemo {

public static void main(String[] args) throws Exception{

writeObj();

readObj();

}

public static void readObj()throws Exception{

ObjectInputStream ois = new ObjectInputStream(new FileInputStream(""));

Object obj = ();etName()

线程的名称是由：Thread-编号定义的。编号从0开始。

线程要运行的代码都统一存放在了run方法中。

线程要运行必须要通过类中指定的方法开启。start方法。（启动后，就多了一条执行路径）

start方法：1）、启动了线程；2）、让jvm调用了run方法。

创建线程的第一种方式：继承Thread ，由子类复写run方法。

步骤：

1，定义类继承Thread类；

2，目的是复写run方法，将要让线程运行的代码都存储到run方法中；

3，通过创建Thread类的子类对象，创建线程对象；

4，调用线程的start方法，开启线程，并执行run方法。

线程状态：

被创建：start()

运行：具备执行资格，同时具备执行权；

冻结：sleep(time),wait()—notify()唤醒；线程释放了执行权，同时释放执行资格；

临时阻塞状态：线程具备cpu的执行资格，没有cpu的执行权；

消亡：stop()

创建线程的第二种方式：实现一个接口Runnable。

步骤：

1，定义类实现Runnable接口。

2，覆盖接口中的run方法（用于封装线程要运行的代码）。

3，通过Thread类创建线程对象；

4，将实现了Runnable接口的子类对象作为实际参数传递给Thread类中的构造方法。

为什么要传递呢因为要让线程对象明确要运行的run方法所属的对象。

5，调用Thread对象的start方法。开启线程，并运行Runnable接口子类中的run方法。

Ticket t = new Ticket();

/*

直接创建Ticket对象，并不是创建线程对象。

因为创建对象只能通过new Thread类，或者new Thread类的子类才可以。

所以最终想要创建线程。既然没有了Thread类的子类，就只能用Thread类。

*/

Thread t1 = new Thread(t);法名

当同步方法被static修饰时，这时的同步用的是哪个锁呢

静态方法在加载时所属于类，这时有可能还没有该类产生的对象，但是该类的字节码文件加载进内存就已经被封装成了对象，这个对象就是该类的字节码文件对象。

所以静态加载时，只有一个对象存在，那么静态同步方法就使用的这个对象。

这个对象就是类名.class

同步代码块和同步方法的区别

同步代码块使用的锁可以是任意对象。

同步方法使用的锁是this，静态同步方法的锁是该类的字节码文件对象。

在一个类中只有一个同步的话，可以使用同步方法。如果有多同步，必须使用同步代码块，来确定不同的锁。所以同步代码块相对灵活一些。

-------------------------------------------------------

---------------------------------------------------------

同步死锁：通常只要将同步进行嵌套，就可以看到现象。同步方法中有同步代码块，同步代码块中还有同步方法。

线程的停止：通过stop方法就可以停止线程。但是这个方式过时了。

停止线程：原理就是让线程运行的代码结束，也就是结束run方法。

怎么结束run方法一般run方法里肯定定义循环。所以只要结束循环即可。

第一种方式：定义循环的结束标记。

第二种方式：如果线程处于了冻结状态，是不可能读到标记的，这时就需要通过Thread类中的interrupt方法，将其冻结状态强制清除。让线程恢复具备执行资格的状态，让线程可以读到标记，并结束。

---------< >----------

interrupt()：中断线程。

setPriority(int newPriority)：更改线程的优先级。

getPriority()：返回线程的优先级。

toString()：返回该线程的字符串表示形式，包括线程名称、优先级和线程组。

()：暂停当前正在执行的线程对象，并执行其他线程。

join：临时加入一个线程的时候可以使用join方法。

当A线程执行到了B线程的join方式。A线程处于冻结状态，释放了执行权，B开始执行。A 什么时候执行呢只有当B线程运行结束后，A才从冻结状态恢复运行状态执行。

史上最全Java基础知识点归纳

史上最全Java基础知识点归纳 写这篇文章的目的是想总结一下自己这么多年来使用Java的一些心得体会，主要是和一些Java基础知识点相关的，所以也希望能分享给刚刚入门的Java 程序员和打算入Java开发这个行当的准新手们，希望可以给大家一些经验，能让大家更好学习和使用Java。 这次介绍的主要内容是和J2SE相关的部分，另外，会在以后再介绍些J2EE 相关的、和Java中各个框架相关的内容。 经过这么多年的Java开发，以及结合平时面试Java开发者的一些经验，我觉得对于J2SE方面主要就是要掌握以下的一些内容。 1.JVM相关(包括了各个版本的特性) 对于刚刚接触Java的人来说，JVM相关的知识不一定需要理解很深，对此里面的概念有一些简单的了解即可。不过对于一个有着3年以上Java经验的资

深开发者来说，不会JVM几乎是不可接受的。 JVM作为Java运行的基础，很难相信对于JVM一点都不了解的人可以把Java语言吃得很透。我在面试有超过3年Java经验的开发者的时候，JVM几乎就是一个必问的问题了。当然JVM不是唯一决定技术能力好坏的面试问题，但是可以佐证Java开发能力的高低。 在JVM这个大类中，我认为需要掌握的知识有： JVM内存模型和结构 GC原理，性能调优 调优：Thread Dump，分析内存结构 class二进制字节码结构，class loader体系，class加载过程，实例创建过程 方法执行过程 Java各个大版本更新提供的新特性(需要简单了解) 2.Java的运行（基础必备） 这条可能出看很简单，Java程序的运行谁不会呢？不过很多时候，我们只是单纯通过IDE去执行Java程序，底层IDE又是如何执行Java程序呢？很多人并不了解。

java知识点总结

https://www.wendangku.net/doc/4e1328259.html,ng.Object 类，是所有类的根父类！ 2.Object类仅有一个空参的构造器public Object(){ } 3.关于方法： ①equals(Object obj) public boolean equals(Object obj) { return (this == obj); } // == // 1.基本数据类型：根据基本数据类型的值判断是否相等。相等返回true，反之返回false // 注：两端数据类型可以不同，在不同的情况下，也可以返回true。 // 2.引用数据类型：比较引用类型变量的地址值是否相等。 //equals(): >①只能处理引用类型变量②在Object类，发现equals()仍然比较的两个引用变量的地址值是否相等 >像String 包装类File类Date类这些重写Object类的equals()方法，比较是两个对象的 //"实体内容"是否完全相同。 >若我们自定义一个类，希望比较两个对象的属性值都相同的情况下返回true的话，就需要重写Object类的 equals(Object obj)方法 ②toString()方法

当我们输出一个对象的引用时，会调用toString()方法。 1.public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); } 当我们没有重写Object类的toString()方法时，打印的就是对象所在的类，以及对象实体在堆空间的位置 2.一般我们需要重写Object类的toString()方法，将此对象的各个属性值返回。 3.像String类、Date、File类、包装类都重写了toString()方法。 1. String类：不可变的字符序列（如：String str = "atguigu"; str += "javaEE"） 1.关注于String常用的方法！ 2.String类与基本数据类型、包装类；与字符数组、字节数组； * 1.字符串与基本数据类型、包装类之间转换 * ①字符串--->基本数据类型、包装类:调用相应的包装类的parseXxx(String str); * ①基本数据类型、包装类--->字符串:调用字符串的重载的valueOf()方法 *

java基础知识点总结

Created by AIwen on 2017/5/14. java是面向对象的程序设计语言；类可被认为是一种自定义的数据类型，可以使用类来定义变量，所有使用类定义的变量都是引用变量，它们将会引用到类的对象。类用于描述客观世界里某一类对象的共同特征，而对象则是类的具体存在，java程序使用类的构造器来创建该类的对象。 java也支持面向对象的三大特征：封装、继承、和多态。java提供了private、protected、和public三个访问控制修饰符来实现良好的封装，提供了extends关键字让子类继承父类，子类继承父类就可以继承到父类的成员变量和和方法，如果访问控制允许，子类实例可以直接调用父类里定义的方法。继承是实现类复用的重要手段。使用继承关系来实现复用时，子类对象可以直接赋给父类变量，这个变量具有多态性。 面向对象的程序设计过程中有两个重要的概念：类（Class)和对象（object，也被称为实例，instance）。类可以包含三种最常见的成员：构造器、成员变量、和方法。 构造器用于构造该类的实例，java语言通过new关键字类调用构造器，从而返回该类的实例。构造器是一个类创建对象的根本途径，如果一个类没有构造器，这个类通常无法创建实例。因此java语言提供了一个功能：如果程序员没有为一个类编写构造器，则系统会为该类提供一个默认的构造器，这个构造器总是没有参数的。一旦程序员为一个类提供了构造器，系统将不再为该类提供构造器。 构造器用于对类实例进行初始化操作，构造器支持重载，如果多个重载的构造器里包含了相同的初始化代码，则可以把这些初始化代码放置在普通初始化块里完成，初始化块总在构造器执行之前被调用。静态初始化块代码用于初始化类，在类初始化阶段被执行。如果继承树里某一个类需要被初始化时，系统将会同时初始化该类的所有父类。 构造器修饰符：可以是public、protected、private其中之一，或者省略构造器名：构造器名必须和类名相同。 注意：构造器既不能定义返回值类型，也不能使用void声明构造器没有返回值。如果为构造器定义了返回值类型，或使用void声明构造器没有返回值，编译时不会出错，但java会把这个所谓的构造器当成方法来处理——它就不再是构造器。 实际上类的构造器是有返回值的，当使用new关键字来调用构造器时，构造器返回该类的实例，可以把这个类的实例当成构造器的返回值。因此构造器的返回值类型总是当前类，无须定义返回值类型。不要在构造器里显式的使用return来返回当前类的对象，因为构造器的返回值是隐式的。 java类名必须是由一个或多个有意义的单词连缀而成的，每个单词首字母大写，其他字母全部小写，单词与单词之间不要使用任何分隔符。 成员变量： 成员变量的修饰符：public、protected、private、static、final前三个只能出现一个再和后面的修饰符组合起来修饰成员变量，也可省略。 成员变量：由一个或者多个有意义的单词连缀而成，第一个单词首字母小写，后面每个单词首字母大写，其他字母全部小写，单词与单词之间不要使用任何分隔符。 类型：可以是java语言允许的任何数据类型，包括基本类型和引用类型。 成员方法： 方法修饰符：public、protected、private、static、final、abstract，前三个只能出现一个，static和final最多只能出现其中的一个，和abstract组合起来使用。也可省略。 返回值类型：可以是java语言的允许的任何数据类型，包括基本类型和引用类型。 方法名：和成员变量的方法命名规则相同，通常建议方法名以英文动词开头。 方法体里多条可执行语句之间有严格的执行顺序，排在方法体前面的语句总先执行，排在方法体后面的语句总是后执行。 static是一个特殊的关键字，它可用于修饰方法、成员变量等成员。static修饰的成员表明它属于这个类本身，而

《Java编程基础知识点汇总及习题集》--答案

目录 第一章Jaｖa入门2? 第二章 Java基础5? 第三章条件转移1?４ 第四章循环语句20? 第五章方法 ............................................... ２6 第六章数组33? 第七章面向对象........................................... 4２第八章异常63? ? 第一章Jaｖａ入门 知识点汇总 1、JAVA 三大体系 ?Jａva ＳE：（J2SE，Jａva2 Plａtｆｏrm Ｓｔandaｒd Edｉtion,标准版），三个 平台中最核心的部分，包含Jaｖa最核 心的类库。?JａvaEＥ:(J2EＥ，Jａva 2 Platfｏｒｍ, EｎteｒpｒisｅEditiｏｎ，企业版）, 开发、装配、部署企业级应用，包含 Servlet、ＪSP、ＪａｖａＢeａn、ＪDB Ｃ、ＥJＢ、Web Ｓerｖice等。 ?Java ＭE:（J2ＭE,Jａva 2 Pｌaｔfｏr ｍMicｒo Ediｔiｏn，微型版），用于 小型电子设备上的软件开发。

2、JDK，JRＥ,JＶＭ的作用及关系 作用 ★JVM：保证Jaｖａ语言跨平台 ★JRＥ：Javａ程序的运行环境 ★ＪＤK:Jaｖa程序的开发环境 关系 ★JDK:JRE+工具 ★JRE:ＪＶM+类库 3、ＪDＫ环境变量配置 ?pａtｈ环境变量:存放可执行文件的存 放路径,路径之间用逗号隔开 ?classpａth环境变量：类的运行路径,J ＶＭ在运行时通过cｌasspａth加载需 要的类 4、重点掌握两个程序 ?javac．eｘe:Java编译器工具，可以将 编写好的Ｊava文件（．jａva）编译成 Ｊava字节码文件（．cｌaｓs）； ?javａ.ｅxe:Jaｖa运行工具，启动Jaｖa 虚拟机进程，运行编译器生成的字节 码文件(．ｃlass） 5、一切程序运行的入口 puｂｌｉｃstaｔic vｏiｄmain(Strｉng aｒgs []）｛ Syｓtem．out.ｐriｎtｌｎ（“Hel ｌo Ｗorld!”）； } 课堂笔记 练习题 一、填空题 1、Java的三个技术平台分别是（J2SE )、（Ｊ2EE)、(J2ME）。 2、Sun公司针对领域不同，提供了三个Jaｖa版本,其中对于个人计算机程序开发的是( Ｊ2SE ), 对于企业开发应用的是（J2EE)，对于嵌入式设备应用开发的是( J２ＭＥ )。 （ｃｌasｓｐａth )。 3、建立Java开发环境，安装ＪＤK,一般需要设置环境变量（path）、 4、编写一个Jａva源程序,其文件名为Teｓt．java，则编译该源程序的命令为（javac )，运行 该程序的命令为( java），生成文档注释的命令为( javadoc)。 5、Java程序的运行环境简称之为( JRE)。

《Java编程基础知识点汇总及习题集》--答案

目录 第一章 Java入门 (2) 第二章 Java基础 (5) 第三章条件转移 (16) 第四章循环语句 (22) 第五章方法 (28) 第六章数组 (35) 第七章面向对象 (44) 第八章异常 (65)

第一章Java入门 知识点汇总 1、JAVA 三大体系 ?Java SE：（J2SE，Java2 Platform Standard Edition，标准版），三个平台中最核心 的部分，包含Java最核心的类库。 ?JavaEE：（J2EE，Java 2 Platform, Enterprise Edition，企业版），开发、装 配、部署企业级应用，包含Servlet、JSP、 JavaBean、JDBC、EJB、Web Service等。 ?Java ME：（J2ME，Java 2 Platform Micro Edition，微型版），用于小型电子设备 上的软件开发。 2、JDK,JRE,JVM的作用及关系 作用 ★JVM：保证Java语言跨平台 ★JRE：Java程序的运行环境 ★JDK：Java程序的开发环境 关系 ★JDK：JRE+工具 ★JRE：JVM+类库 3、JDK环境变量配置 ?path环境变量：存放可执行文件的存 放路径，路径之间用逗号隔开 ?classpath环境变量：类的运行路径， JVM在运行时通过classpath加载需要 的类 4、重点掌握两个程序 ?javac.exe：Java编译器工具，可以将编 写好的Java文件（.java）编译成Java 字节码文件（.class）; ?java.exe：Java运行工具，启动Java虚 拟机进程，运行编译器生成的字节码 文件(.class) 5、一切程序运行的入口 public static void main（String args []）{ System.out.println(“Hello World!”); } 课堂笔记

JAVA技术--Java基础知识常见考试题JAVA技术.doc

一、单选题 1.对类：(B) public class Test( //...do something } 下面那个正确地定义了类Test的构造函数。 A)public void Test() () B)publicTest()(} C ) public static Test() (} D) publicTest(); 2.下面哪个函数是public void example()(...)的重载函数。(A) A)public void example( float f)(...) B)public int example() (...) C)public void example2()(...} D)public int example_overLoad ()(...) 3.下面的代码段中，执行之后i和j的值是_C_。 int i = 1; intj； j = i++； A)1, 1 B) 1,2 C) 2, 1 D) 2,2 4.以下for循环的执行次数是_B o for(int x=0,y=0;(y !=0)&&(x<4) ;x++); A)无限次B) 一次也不执行 C)执行4次D)执行3次 5.下面程序的输出结果是—C o public class People( String name; int id; public People( String str, int n )( name = str; id = n; } public String toString(){ return id + " ：” + name; } public String print()(

--动力节点之java的知识点归纳总结

1. 基本数据类型 整形： byte 1 个字节 short 2 个字节 int 4个字节 long 8个字节 字符： char 2个字节 浮点数： float 4个字节 double 8个字节 布尔： boolean 1个字节 2.java 7 新增二进制整数 以0b或者0B开头 3.java中字符时16位的Unicode编码方式，格式是'\uXXXX'，其中xxxx代表一个十六进制整数 4.java中规定了正无穷大、负无穷大和零 正无穷大= 一个正数除以0 负无穷大= 一个负数除以零 0.0 除以0.0 或者对一个负数开方得到一个非数 5. 在java中布尔类型只能是true和false 6. 在java中没有多维数组 动力节点

看似像C语言中的多维数组不是真正的数组，比如 a[3][4] , a[0] a[1] a[2] 是真实存在的，装的是地址，和 c语言中动态分配为的数组一样 int [][] b = new int[3][4] 7. Java中带包的编译方法 javac -d . Hello.java 会在当前目录下生成目录树 运行 java 包名字.类名字 8. Java多态中的对象的filed 不具有多态性，如父类对象 = new 子类（），对象.field 是调用的父类的，即使子类中覆盖了该字段。 9. instanceof 运算符 格式：引用变量名 instanceof 类名（或者接口）他用于判断前面的对象是否是后面对象的类，子类、实 现类的实例，是返回true，否者返回false 10. Java 中基本数据类型和对应封装类之间的转化 int a = 1; Integer A = new Integer(a); a = A.intValue(); 其他的类型也是这样的。 11.单例（singleton）类例子 复制代码代码如下: class Singleton { private static Singleton instance; private Singleton(){} public static Singleton getInstance() { 动力节点

Java编程基础知识点汇总及习题集答案

J a v a编程基础知识点汇总及习题集答案 集团文件发布号：（9816-UATWW-MWUB-WUNN-INNUL-DQQTY-

目录 第一章 Java入门 (2) 第二章 Java基础 (5) 第三章条件转移 (14) 第四章循环语句 (20) 第五章方法 (26) 第六章数组 (33) 第七章面向对象 (42) 第八章异常 (63) 第一章 Java入门 知识点汇总 1、JAVA 三大体系 Java SE：（J2SE，Java2 Platform Standard Edition，标准版），三个平台中最核心的部分，包含Java 最核心的类库。 JavaEE：（J2EE，Java 2 Platform, Enterprise Edition，企业版），开发、装配、部署企业级应用，包含Servlet、JSP、JavaBean、JDBC、EJB、Web Service等。 Java ME：（J2ME，Java 2

Platform Micro Edition，微型版），用于小型电子设备上的软件开发。 2、JDK,JRE,JVM的作用及关系作用 ★JVM：保证Java语言跨平台 ★JRE：Java程序的运行环境 ★JDK：Java程序的开发环境 关系 ★JDK：JRE+工具 ★JRE：JVM+类库 3、JDK环境变量配置 path环境变量：存放可执行文件的存放路径，路径之间 用逗号隔开 classpath环境变量：类的运行路径，JVM在运行时通过classpath加载需要的类 4、重点掌握两个程序 ：Java编译器工具，可以将编写好的Java文件（.java）编译成Java字节码文件（.class）; ：Java运行工具，启动Java虚拟机进程，运行编译器生成的字节码文件(.class) 5、一切程序运行的入口public static void main （String args []）{ World!”); } 课堂笔记

java期末考试知识点总结

java知识点总结 应同学要求，特意写了一个知识点总结，因比较匆忙，可能归纳不是很准确，重点是面向对象的部分。 java有三个版本：JAVA SE 标准版\JAVA ME移动版\JAVA EE企业版 java常用命令：java, javac, appletview java程序文件名：.java, .class java的两类程序：applet, application; 特点，区别，这两类程序如何运行 java的主方法，主类，共有类；其特征 java的数据类型，注意与C++的不同，如字符型，引用型，初值 java与C++的不同之处，期中已总结 java标记符的命名规则 1）标识符有大小写字母、下划线、数字和$符号组成。 2）开头可以是大小写字母，下划线，和$符号（不能用数字开头） 3）标识符长度没有限制 4）标识符不能使关键字和保留字 面向对象的四大特征 抽象、封装、继承、多态 封装，类、对象，类与对象的关系，创建对象，对象实例变量 构造函数，默认构造函数，派生类的构造函数，构造函数的作用，初始化的顺序，构造方法的重载 构造函数：创建对象的同时将调用这个对象的构造函数完成对象的初始化工作。把若干个赋初值语句组合成一个方法在创建对象时一次性同时执行，这个方法就是构造函数。是与类同名的方法，创建对象的语句用new算符开辟了新建对象的内存空间之后，将调用构造函数初始化这个新建对象。 构造函数是类的特殊方法： 构造函数的方法名与类名相同。 构造函数没有返回类型。 构造函数的主要作用是完成对类对象的初始化工作。 构造函数一般不能由编程人员显式地直接调用。 在创建一个类的新对象的同时，系统会自动调用该类的构造函数为新对象初始化。 类的修饰符：public类VS 默认; abstract类; final类; 1）类的访问控制符只有一个：public，即公共的。公共类表明它可以被所有其他类访问和引用。 若一个类没有访问控制符，说明它有默认访问控制特性，规定该类智能被同一个包中的类访问引用（包访问控制）。 2）abstract类：用abstract修饰符修饰的类被称为抽象类，抽象类是没有具体对象的概念类，抽象类是它所有子类的公共属性集合，用抽象类可以充分利用这些公共属性来提高开发和维护效率。 3）final类：被final修饰符修饰限定的，说明这个类不能再有子类。所以abstract与final 不能同时修饰一个类。 域和方法的定义 1)域：定义一个类时，需要定义一组称之为“域”或“属性”的变量，保存类或对象的数据。

java各知识点详细总结(毕向东笔记整理)

Java基础知识总结 写代码： 1，明确需求。我要做什么？ 2，分析思路。我要怎么做？1,2,3。 3，确定步骤。每一个思路部分用到哪些语句，方法，和对象。 4，代码实现。用具体的java语言代码把思路体现出来。 学习新技术的四点： 1，该技术是什么？ 2，该技术有什么特点(使用注意)： 3，该技术怎么使用。demo 4，该技术什么时候用？test。 ----------------------------------------------------------------------------------------------- 一：java概述： 1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器； 1994年将Oak语言更名为Java； Java的三种技术架构: JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发； JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发，是其它两者的基础； JAVAME：Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的程序； 1，JDK：Java Development Kit，java的开发和运行环境，java的开发工具和jre。 2，JRE：Java Runtime Environment，java程序的运行环境，java运行的所需的类库+JVM(java 虚拟机)。 3，配置环境变量：让java jdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。 环境变量的配置： 1）：永久配置方式：JAVA_HOME=%安装路径%\Java\jdk path=%JAVA_HOME%\bin 2）：临时配置方式：set path=%path%;C:\Program Files\Java\jdk\bin 特点：系统默认先去当前路径下找要执行的程序，如果没有，再去path中设置的路径下找。 classpath的配置: 1）：永久配置方式：classpath=.;c:\;e:\ 2）：临时配置方式：set classpath=.;c:\;e:\ 注意：在定义classpath环境变量时，需要注意的情况 如果没有定义环境变量classpath，java启动jvm后，会在当前目录下查找要运行的类文件； 如果指定了classpath，那么会在指定的目录下查找要运行的类文件。 还会在当前目录找吗？两种情况： 1）：如果classpath的值结尾处有分号，在具体路径中没有找到运行的类，会默认在当前目录再找一次。 2）：如果classpath的值结果出没有分号，在具体的路径中没有找到运行的类，不会再当前目

Java基础阶段复习题2(附答案)

复习题2 如有雷同，纯属巧合！ 1.下列哪一种叙述是正确的() A. abstract修饰符可修饰字段、方法和类 B.抽象方法的body部分必须用一对大括号{ }包住 C.声明抽象方法，大括号可有可无 D.声明抽象方法不可写出大括号 2.下列说法正确的有() A. class中的constructor不可省略 B. constructor必须与class同名，但方法不能与class同名 C. constructor在一个对象被new时执行 D.一个class只能定义一个constructor 3.以下哪个表达式是不合法的（） A、String x=”Hello”; int y=9; x+=y; B、String x=”Hello”; int y=9; if(x= =y) { } C、String x=”Hello”; int y=9; x=x+y; D、String x=null; int y=(x!=null)&&(x.length()>0) ? x.length() : 0 4.下列关于修饰符混用的说法，错误的是（） A．abstract不能与final并列修饰同一个类 B．abstract类中不可以有private的成员 C．abstract方法必须在abstract类中 D．static方法中能处理非static的属性 5.（）修饰符允许对类成员的访问不依赖于该类的任何对象 A、abstract B、static C、return D、public 6.关于被私有访问控制符private修饰的成员变量，以下说法正确的是（） A．可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类 B．可以被两种类访问和引用：该类本身、该类的所有子类 C．只能被该类自身所访问和修改 D．只能被同一个包中的类访问

JAVA知识点总结

第一章面向对象程序设计 一、识记知识 1.结构化程序设计思想、特点、基本过程 思想：⑴自顶向下、逐步求精； ⑵模块化； ⑶语句结构化。 特点：程序设计= 数据结构+ 算法 程序内容= 过程+ 过程调用 基本过程：软件开发的基本过程： 1)需求分析、2)系统分析、3)系统实现、4)系统测试、5)系统维护 结构化贯穿于每个过程中时，其基本过程：分解和组装 2.面向对象程序设计基本思想、特点 基本思想：以对象的观点描述分析现实世界中的问题。从普通人认识世界的观点出发，把事物归类、综合，提取共性并加以描述。 特征：1）所有待处理的内容都表示成对象； 2）对象之间依靠相互发送消息或响应消息实现通信； 3）每个对象有自己的唯一标识，以便区别属于同一个类的不同对象； 4）对象一定属于某个类，这个对象又称为所属类的一个实例； 5）类是将具有共同属性的对象进行抽象的结果，他可以具有层次关系，即一个类既可以通过继承其他类而来，又可以被其他类继承。 通过公式描述：面向对象=类+对象+继承+消息+通信 3.基本概念、面向对象的4个特性 概念： 1）抽象：从许多食物中，舍弃个别的，非本质的属性，抽取出共同的、本质的属性过程，它是形成概念的不要手段。 2）封装：指将显示世界中的某个客体的属性与行为聚集在一个逻辑单元内部的机制。 3）对象：用来描述现实世界中客体的部件，是面向对象软件系统在运行时刻的基本单位。 4）类：是一组具有相同属性特征的对象的抽象描述，是面向对象程序的有一个核心概念。（具体地说，类是面向对象程序的唯一构造单位，是抽象数据类型的具体实现，是对象的生成模板） 5）消息：是一个对象要求另一个对象实施某项操作的请求。（是对象之间相互请求或相互协作的途径，是要求某个对象执行其中某个功能操作的规格的说明） 6）继承：表达了一种对象类的相交关系。是类之间的一种常见关系，为共享数据和操作提供了一种良好的机制。 7）多态：不同的类对象收到同一个消息可以产生完全不同的响应效果。 特性：抽象性、多态性、封装性、继承性 4.消息 概念：是一个对象要求另一个对象实施某项操作的请求。是对象之间相互请求或相互协作的途径，是要求某个对象执行其中某个功能操作的规格的说明。

java基础刷题知识点总结

基础 1.object类的方法有哪些 clone() protect 创建并返回一个对象的副本 equals()用来比较某个对象是否与调用此方法的对象相等 finalize() protect getClass() 返回一个对象的运行时类 hashCode()返回一个对象的hash值 notify()唤醒在此对象监听器上等待的单个线程。如果有多个，则随机唤醒一个 notifyAll()唤醒在此对象监听器上等待的所有线程 registerNatives() 本地私有方法，在类初始化是会调用此方法 toString() 返回当前对象的字符串表示 wait()使当前线程处于等待直到其他线程调用这个对象的notify或notifyAll方法或者超过指定的时间量 2.接口和抽象类的区别 1.首先描述接口和抽象类的特性 抽象类：是子类通用特性的集合 接口:是抽象方法的集合l 从某种意义上说抽象类包含了接口的所有功能。但是通过实现接口可以实现多继承

什么时候用抽象类和接口 1.如果一些方法必须提供默认的实现，就必须用抽象类，比如在dao层，每个类都有增删查改这几个操作，我们可以把这些操作写在抽象类里，并让抽象类提供默认的实现。 否则的话用接口 2.假如要实现多继承，则必须要用接口,java不支持多继承但是可以通过实现多个接口来解决 3.如果基本功能在不断改变，那么就用抽象类。如果不断改变基本功能并且使用接口，子类就必须不停的更改 03.抽象类是否有构造方法 抽象类有构造方法只是抽象类不能够实例化 4.Final finally finalize()方法的区别 5.Sleep()和wait()的区别 ①这两个方法来自不同的类分别是，sleep来自Thread类，和wait来自Object类。sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。 ②锁: 最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。 sleep不出让系统资源；wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。一般wait不会加时间限制，因为如果wait线程的运行资源不够，再出来也没用，要等待其他线程调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS 分配系统资源。sleep(milliseconds)可以用时间指定使它自动唤醒过来，如果时间不到只能调用interrupt()强行打断。 Thread.sleep(0)的作用是“触发操作系统立刻重新进行一次CPU竞争”。 ③使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，配合synchronized实现等待通信机制，而sleep可以在任何地方使用。 synchronized(x){ x.notify() //或者wait() }

java基础知识练习题

Java基础测试题 一、选择题（每题2分） 1、在JAVA编程中，Java编译器会将java程序转换为（）。 A. 字节码； B. 可执行代码； C. 机器代码； D. 以上所有选项都不正确。 2、下列那些不是合法的标识符？（） A. Tel_num B. 8ABc C. Emp_1 D. b123.6 E. NULL F. Hello World 3、以下字符常量中不合法的是( )。 A. '|' B. '\'' C."\n" D.'我' 4、下列语句编译没有错误的是：（） A. float a=1.5; B.byte a=129; C.byte a=5; D.byte a=(byte)200; 5、java中int数据类型在内存中表示为（） A. 2个字节 B.4个字节 C. 由程序员指定 D. 以上都不正确 6、下列程序段执行后t5的结果是( )。 int t1 = 9, t2 = 11, t3=8; int t4,t5; t4 = t1 > t2 ? t1 : t2+ t1; t5 = t4 > t3 ? t4 : t3; A. 8 B.20 C.11 D.9 7、若有定义int a = 2;则执行完语句a += a -= a * a; 后，a的值是( )。 A. 0 B. 4 C. 8 D.–4 8、设 a, b, c, d 均为 int 型的变量，并已赋值，下列表达式的结果属于非逻辑值的是( ) A. a!=b & c%d < a B.a++ = =a+b+c+d C.++a*b--+d D.a+b>=c+d 9、以下代码段执行后的输出结果为（） int x=3； int y=10； System.out.println(y%x); A.0 B.1 C.2 D.3 10、下列语句序列执行后，k 的值是( )。 int i=10, j=18, k=30; switch( j - i ) { case 8 : k++; case 9 : k+=2; case 10: k+=3; default : k/=j; } A. 31 B. 32 C. 2 D.33 11、假定有变量定义: int k=7,x=12; 则能使值为3的表达式是（）。 A. x%=(k%=5) B.x%=(k-k%5) C. x%=k-k%5 D. (x%=k)-(k%=5) 12、设x和y均为int型变量,则以下语句:x+=y；y=x-y；x-=y；的功能是（）。 A. 把x和y按从大到小排列 B. 把x和y按从小到大排列

Java期末知识点整理总结

Java期末知识点整理总结 计科2班苏锐师编号47 学号201330551464 第一章 Java语言概述 1. Java语言发展历史和现状及前景 2. Java语言的特点： 简单、面向对象、分布式、健壮性、结构中立、 安全性、可移植、解释的、高性能、多线程、多态性 3. Java虚拟机概念（JVM），Java程序的执行过程 4. Java应用程序分类：Application和Applet 5. Java程序的开发环境：JDK，IDE 第二章 Java数据类型及其运算 1. 标识符与保留字 1.2 标识符命名语法规则与Java推荐的标识符命名规则 1.3 Java中的关键字 2. 数据类型byte, short, int long, char, float, double, boolean 注意点：Java中所有数据类型是确定的，与平台无关，没有sizeof操作，其中特别注意char 类型是2字节Unicode编码，与C++ 不同；知道基本类型都有对应的默认值。 整型数的十进制、八进制、十六进制值的表示。 实型数的十进制、十六进制与科学计数法表示，注意实型常量默认类型为double型。 3. 运算符与表达式算术运算符： + - * / % ++ -- 关系运算符：> >= < <= == != 逻辑运算符：&& || ！& | 注意短路计算与非短路计算的差别 位运算符： >> << >>> & | ^ ~ 要认识异或(^)与按位取反(~)运算符 赋值运算符： += -= *= /= %= &= |= ^= <<= >>= >>>= 要注意赋值运算符中包含了强制转换： 若： int k = 1; k += 44.232D; 则相当于： k = (int) ( k + 44.232D); 条件运算符：exp ？stat1 ：stat2 要注意stat1与stat2要求类型相兼容且不能为void类型。运算符的优先级：算术运算 > 关系运算> 逻辑运算

java基础知识详细整理(图文并茂深入浅出)

JSE第一部分 分享者：张振羽 2017.6.30

1.什么是 JDK API (1) Application Programming Interface ,应用程序编程接口 (2) 是一些预先定义的函数，开发人员可提供直接调用的功能。 2.JDK包结构 便于维护，按照功能划分，不同功能的累划分在不同功能的包中，常用的包如下表： 3.字符串的基本操作 3.1 String 及其API

3.1.1 String (1) String是不可变对象 (2) https://www.wendangku.net/doc/4e1328259.html,ng.String使用了final修饰，不能被继承。 (3)字符串一旦被初始化，就不可以被改变，存放在方法区中的常量池中 (4) 任何一个字符对应2个字节的长度，1个字节 = 8位二进制。 3.1.2 String s=new String (“abc”) (1) 众所周知，答案是:创建两个对象 (2) why?举例子： 分析步骤： a) 栈中开辟一块空间存放引用str1（地址信息）； b) String池中有一块空间，存放String常量"abc"； c) 引用str1指向池中String常量"abc"； d) str1所指代的地址即常量"abc"所在地址，输出为true； 结论：创建了一个引用对象str1

分析步骤： 1) 栈中开辟一块空间存放引用str3； 2) 堆中开辟一块空间存放一个新建的String对象"abc"； 3) 引用str3指向堆中的新建的String对象"abc"； 4) str3所指代的对象地址为堆中地址，而常量"abc"地址在池中，输出false； 3.2 StringBuilder常见API

java各知识点详细总结

基础知识总结 写代码： 1，明确需求。我要做什么？ 2，分析思路。我要怎么做？1,2,3。 3，确定步骤。每一个思路部分用到哪些语句，方法，和对象。 4，代码实现。用具体的语言代码把思路体现出来。 学习新技术的四点： 1，该技术是什么？ 2，该技术有什么特点(使用注意)： 3，该技术怎么使用。 4，该技术什么时候用？。 一：概述： 1991 年公司的等人开始开发名称为的语言，希望用于控制嵌入在有线电视交换盒、等的微处理器； 1994年将语言更名为； 的三种技术架构: ：，开发企业环境下的应用程序，主要针对程序开发； ：，完成桌面应用程序的开发，是其它两者的基础； ：，开发电子消费产品和嵌入式设备，如手机中的程序； 1，：，的开发和运行环境，的开发工具和。 2，：，程序的运行环境，运行的所需的类库(虚拟机)。 3，配置环境变量：让\目录下的工具，可以在任意目录下运行，原因是，将该工具

所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。 环境变量的配置： 1）：永久配置方式：安装路径%\\ \ 2）：临时配置方式：:\ \\\ 特点：系统默认先去当前路径下找要执行的程序，如果没有，再去中设置的路径下找。 的配置: 1）：永久配置方式：:\:\ 2）：临时配置方式：:\:\ 注意：在定义环境变量时，需要注意的情况 如果没有定义环境变量，启动后，会在当前目录下查找要运行的类文件； 如果指定了，那么会在指定的目录下查找要运行的类文件。 还会在当前目录找吗？两种情况： 1）：如果的值结尾处有分号，在具体路径中没有找到运行的类，会默认在当前目录再找一次。 2）：如果的值结果出没有分号，在具体的路径中没有找到运行的类，不会再当前目录找。 一般不指定分号，如果没有在指定目录下找到要运行的类文件，就报错，这样可以调试程序。 4，命令和命令做什么事情呢？ 要知道是分两部分的：一个是编译，一个是运行。 ：负责的是编译的部分，当执行时，会启动的编译器程序。对指定扩展名的文件进

Java基础知识整理

Java知识点总结 1环境搭建与开发 1.1 环境变量 JA V A_HOME：Java的安装目录； CLASSPATH：指定一个路径列表，用于搜索Java在编译或运行时需要用到的类（.class文件）； PATH：指定一个路径列表，用于搜索可执行文件。 1.2 Java SDK应用 编译：Javac 类名.class； 运行：Java 类名； 打包：jar cf test.jar test （把当前目录下的test目录下的所有文件压缩到test.jar文件中）。 2变量与常量 Java中的常量用保留字final来实现。 变量：局部变量（local variable）、实例变量（instance variable）、类变量（class variable）；任何变量在使用前都必须初始化，局部变量必须显示初始化，实例变量在类的构造方法被调用时初始化（分配默认值），类变量在类被加载时被初始化。 3标识符 3.1 命名 在Java语言中，标识符的定义规则是以字母、下划线、美元符开始，后面可以跟字母、下划线、美元符、数字。 因为Java语言使用Unicode字符集，所以对字母不仅限于英文，还可以是日文、韩文、阿拉伯文、中文等。 区分大小写，没有字数限制。

3.2 关键字 3.2.1static static方法中不能有this和super关键字（static方法不是“面向对象”的，而是“面向类”的）。 static方法中只能访问所属类的static方法和变量。 static数据成员的初始化：在第一次生成该类的对象时初始化。 3.2.2final 1)final数据 a)static final ●更加典型的定义方式是public static final； ●占用一段不能改变的存储空间； ●代表编译时常量，即在编译器就能知道其值（如果只声明为final或 者static，是在运行时才知道值）。 ●全部用大写字母命名，单词之间用下划线隔开。 b)final数据与final引用 ●final数据的值不能被改变； ●final引用是指无法将其指向一个新的对象（数组也是一种引用），对 象本身的值是可以改变的。 c)空白final（声明为final却未赋初始值） ●可以做到根据对象有所不同，又保持恒定不变的特性； ●必须保证使用前已经初始化：在定义处赋值或者在构造器中赋值。 2)final参数 ●无法在方法中更改引用所指向的对象。 3)final方法 ●禁止覆盖，防止任何继承类修改它的定义； ●private方法都是final的，因此private方法无法覆盖。 4)final类 ●不允许继承该类； ●final类中的所有方法都隐式指定为final的。

Java知识点总结(word文档良心出品)

JAVA知识点总结 1. JAVA的特点: （0简单易用、完全面向对象； ⑦与平台无关性、可扩展性强； （0可移植性高、支持分布式编程; ④健壮、安全可靠并性能优异； ⑤支持多线程开发技术； （0支持动态开发。 2. JVM： Java虚拟机（JVM是Java实现跨平台的基础）。 Java的源程序（*.jav 一）_＞编译（命令：java+文件名.java ）--------------------- ? Java字节码（*.class 编译时自动形成，与源程序名一致） -------- 运行（命令：java+源程 序的文件名--------- JVM （Windows、Linux） 广开发工具，Javac及基础核心类 JD K L 运行环境，Java及基础核心类 3. 编写第一个Java程序： Java源文件扩展名为：” .java ” 一个源文件中最好只有一个java类，但是可以包含多个类public修饰的类，文件名与类名必须一致（包括大小写）被运行的类中需要有一个方法： public static void main（String[ ] args）{} 一个源文件中最多有一个public修饰的类 例如：public class Test{ public static void main（String args[]）{ System.out.println（"这个编写的第一个java 程序！！！” ）; } } 在运行程序之前先配置环境变量： path变量值为：JDK安装目录下bin ; classpath 变量值为：JDK安装目录下lib ; 或.;JDK安装目录下lib tools.jar 在dos命令窗口中输入以下命令进行运行： 编译命令:javac Test.java 运行命令：java Test 生成文档命令：javadoc Test.java 4. Java编程规范 A、命名规定 包：包名应该是小写的名词。 女口：package shipping.objects