Java知识点的总结

一、Java语言概述

1、精通一门语言

2、掌握一门流行框架

3、熟悉一些前端(HTML，css，js，jQuery)

4、熟悉一种数据库----->大数据oracle

5、了解一些服务器操作系统

二、javaSE--->桌面系统

CS(客户端系统)/BS()

JavaEE

JavaEE是一个开发分布式企业级应用的规范和标准。

Java语言的平台有3个版本：适用于小型设备和智能卡的JavaME（Java Platform Micro Edition，Java微型版）、

适用于桌面系统的JavaSE（Java Platform Micro Edition，Java标准版）、

适用于企业应用的JavaEE（Java Platform Enterprise Edition，Java企业版）。

JavaEE包含的技术：

JavaEE应用程序是由组件构成的。J2EE组件是具有独立功能的单元，他们通过相关的类和文件组装成JavaEE应用程序，并与其他组件交互。

JavaEE包括的技术有：Web Service、Struts、Hibernate、Spring、JSP、Servlet、JSF、EJB、JavaBean、JDBC、JNDI、XML、JavaSE

三、

final String name="asdf";

错误： name = name + "aaaa";

位运算符：<<>>>>>& | !

四、this 和 super的区别：

this代表什么？这儿代表New出来的那个玩意儿在堆空间的引用地址

1、通过this关键可以明确的去访问一个类的成员变量，解决与局部变量

名称冲突问题。

2、通过this关键字调用成员方法。

3、构造方法是在实例化对象时被Java虚拟机自动调用的，在程序中不能

像调用其他方法一样去掉用构造方法，但可以在一个构造方法中使用

“this([参数1，参数2，..])”的形式来调用其他的构造方法。

使用this构造方法中，应注意以下几点。

1、只能在构造方法中使用this调用其他的构造方法，不能再成员方法中

使用。

2、在构造方法中，使用this调用构造方法语句必须位于第一行，且只能

出现一次。

3、不能再一个类的两个构造方法中使用this互相调用。

列如：Father f = new Child();

** F这个变量里面放的就是this，是new Child()这个玩意的对空间的引用地址。

这里定义成Father类，只有Father类的属性和方法是可见的。

父类中写的this这个其实就是父类或其他子类、孙子类在运行的时候【重复一次】new 子类、new孙子类……的对空间的的引用地址

1、在静态方法中不可以使用this关键字

2、在静态方法中不可以直接调用非静态方法。

3、Java中规定不能将方法体内的局部变量声明为static。

●super代表什么？

在Java中专门提供了一个super关键字用于访问父类的成员，例如访问

父类的成员变量，成员方法，和构造方法。

1、使用super关键字调用父类的成员变量和成员方法。

2、使用super调用关键字父类的构造方法。

●Final关键字？

Final修饰的类不能被继承。

Final修饰的方法不能被子类重写。

Final修饰的变量是常量，只能被赋值一次。

Super只是记录对象内部的父类的特征(属性和方法)的引用，只是执行了

父类的构造方法将父类的特征生成了，但是属于new出来的那个子类对象。

fc1这个变量里面放的就是this,是new SunziClass()这个玩意儿在堆空间的引用地址.

●Static 关键字

在Java中定义一个static关键字，它用于修饰类的成员，如成员变量，成员方法

以及代码块等。

在一个Java类中，可以使用static关键字修饰成员变量，该变量被称为静态变量。

静态变量被所有实例共享，可以使用“类名.变量名”的形式来访问。

注意：static关键字只能修饰成员变量，不能用于修饰局部变量，否则编译会出错。

●静态方法：不创建对象的情况下就可以调用的方法。

在一个静态方法中只能访问用static修饰的成员，原因在于没有被static修饰的

成员需要先创建对象才能访问，而静态方法在被调用时可以不创建任何对象。

●单例模式

单利模式是Java中的一种设计模式，它是指在设计一个类时，需要在保证整个程序

运行期间针对该类只存在一个实例对象。

1、类中定义一个无参的构造方法，并且声明private修饰，声明为私有。这样就

不能再类的外部使用new关键字来创建实例对象。

2、在内部创建一个该类的实例对象，使用静态变量引用实例对象。

3、使用private修饰静态变量，禁止外界直接访问。

4、定义静态方法返回该类的实例。

●内部类

在Java中，允许在一个类的内部定义类，这样的类称作内部类，这个内部类所在的类称作外部类。根据内部类的位置，修饰符和定义的方式可以分为成员内部类，静态内部类，方法内部类。

1、成员内部类是外部类的一个成员，可以访问外部类的其他成员。

2、外部类可以访问成员内部类的成员。

3、方法内部类只能在其定义的当前方法中进行是实例化。

4、静态内部类中可以定义静态成员，也可以定义非静态成员。

●静态内部类

可以使用static关键字来修饰一个成员内部类，该内部类被称作静态内部类，它可以再不创建外部类对象的情况下被实例化。

注意：

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

2、在静态内部类中可以定义静态的成员，而在非静态的内部类中不允许定义静态

的成员。

●方法内部类

方法内部类是指在成员方法中定义的类，他只能当前方法中被使用。

●懒汉模式：只用在自身需要的时候才会行动，从来不知道提早做好准备，他在需

要对象的时候才判断是否已有对象，如果没有就立即创建一个对象，然后返回。如果已有对象就不创建立即返回。懒汉模式只在外部对象第一次请求实例的时候才去创建。

●饿汉模式：就是加载这个类的时候立马创建。

●抽象类和接口

但定义一个类时，常常需要定义一些方法来描述该类的行为特征，但有时这些类的方法的实现是无法确定的。Java允许在定义方法的时候不写方法体，不包含方法体的方法被称为抽象方法，抽象方法必须使用abstract关键字来修饰，使用abstract 关键字修饰的类为抽象类。

包含抽象方法的类必须声明为抽象类，但抽象类可以不包含任何抽象方法，只需要abstract关键字来修饰即可。

抽象类是不可以被实例化的，因为抽象类中可能包含抽象方法，抽象方法没有方法体，不可以被调用。

接口：一个抽象类中所有的方法都是抽象的，则可以将这类用另外一种方式来定义，即接口。

&：接口中定义的方法和变量都包含一些默认的修饰符，接口中定义的默认使用“public abstract”来修饰，即抽象方法。接口中的变量默认使用“public static

final”来修饰，即全局常量。

&：由于接口中的方法都是抽象方法，因此不能通过实例化对象的方式来调用接口中的方法。需要定义一个类，并且使用implements 关键字来实现接口中的所有的方法。

&：接口中的方法都是抽象，不能被实例化对象。

&：当一个类实现接口时，如果这个类是抽象类，则实现接口中的部分方法即可，否则要实现接口中的所有的方法。

&：一个类通过Implements关键字实现接口时，可以实现多个接口，被实现的多个接口之间要用逗号隔开。

&：一个类在继承另一个类的同时还可以实现接口，此时，extends关键字必须为与implements关键字之前。

●多态：

在Java中为了实现多态，允许使用一个父类类型的变量来引用一个子类类型的对象，根据被引用子类对象特征的不同，得到不同的运行结果。

Java提供了一个关键字instanceof，他可以判断一个对象是否为某个类(或接口)的实例或者子类的实例。

●多线程

多线程就是指一个应用程序中有多条并发执行的线索，每条线索都被称作线一个程，它们之间会交替执行，彼此之间可以进行通讯。

1、继承thread类创建多线程

JDK中提供了一个线程类，通过继承Thread类，并重写Thread类中的run()方

法便可以实现多线程。Thread类中提供了一个start()方法用于启动新线程，

线程启动后就会调用run()方法。

注意：Thread类实现多线程有一定的局限性。Java中只支持单继承，一个类继

承了某个父类就无法在继承Thread类。

2、实现Runnable接口实现从创建多线程。

Thread类提另外提供了一个构造方法Thread(Runnable target)，其中Runnable

是一个接口，它只有一个Run()方法。

3、线程的声明周期及状态转换

线程的生命周期分为五个阶段：新建状态(new),就绪状态(Runnable),运行状态

(running)，阻塞状态(blocked)和死亡状态(Terminated),线程的不同状态表名

了线程当前正在进行的活动。

4、后台线程

对于Java来说，只要还有一个前台进程还在运行，这个进程就不会结束，如果

一个进程中只有后台进程运行，这个进程就会结束。

5、关于线程的创建：

①定义Thread类的子类，重写Thread类的Run()方法，创建该子类的实例对

象，调用子类对象的start()方法。

②定义一个实现Runnable接口的类并实现Run()方法，创建该类的实例对象，

将其作为参数传递给Thread类的构造方法来创建Thread对象，调用Thread

对象的start()方法。

6、对于wait()方法：

Wait()方法的调用者是同步锁。

Wait()方法使线程进入等待状态。

调用同一锁对象的notify()或notifyAll()方法可以唤醒调用wait()方法等待

的线程。

调用wait()方法的线程回释放同步锁对象。

●Java API String类和StringBuffer类

String类的初始化。

●StringBuffer类：由于字符串是常量，因此一旦创建，其内容和长度都是不可以

改变的。如果需要一个字符串进行修改，只有创建新的字符串。为了便于对字符的修改，在JDK中提供了一个Stringbuffer类(字符串缓冲区)

StringBuffer和String类的最大的区别在于StringBuffer的内容和长度都可以改变。StringBuffer类似一个字符容器，当在其中添加或删除字符是，并不会产生新的Buffer对象。

注意StringBuffer和String的区别：

①：String类表示字符串是常量，一旦创建后，内容和长度都无法改变。而

StringBuffer表示的是字符容器，其内容和长度都可以改变。在操作字符

串时，如果该字符串仅表示数据类型，则使用String类即可，如果要对字

符串中的字符进行增删操作，则使用StringBuffer类。

②String类覆盖了Object类的equals()方法，而StringBuffer类没有覆盖

Object类的equals()方法。

③Sting类对象可以用操作符+进行连接，而StringBuffer类对象之间不能。

●Runtime类

Runtime类表示虚拟机运行的状态，它用于封装JVM虚拟机进程。每次使用Java命令启动虚拟机都对应一个Runtime实例，并且只有一个实例，因此该类采用单例模式进行设计，对象不可以直接实例化。

●包装类:

包装类和基本数据类型在进行装换时，引入类装箱和拆箱的概念，其中装箱是指基

本数据类型装换成引用数据类型。反之，拆箱是将引用类型装换成基本数据类型。

●集合类

集合概述：在程序中可以通过数组来保存多个对象，但在某些情况下无法确定到底

要保存多少对象，此时数组将不再适用，因为数组的长度不可变。

集合按照存储结构可以分为两大类：单列集合Collection和双列集合Map这两种集

合都位于Java.util包中。

&Collection:单列集合的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口。分别是List和Set。其中List的特点是元素有序，元素可以

重复。Set的特点是元素无序不可重复。List接口实现类有ArrayList和LinkedList，Set接口主要实现的类有HashSet和TreeSet。

&Map：双列集合的根接口，用于存储具有键(key),值(value)映射关系的元素，每个元素都包含一对键值，在使用Map时可以通过制定的key找到对应的Value。

Map接口主要实现的类有HashMap和TreeMap。

●ArrayList集合

ArrayList内部封装了一个长度可以改变的数组对象，但存入的元素超过

数组长度时，ArrayList会在内存中分配一个更大的数组来出存储这些元

素，因此可以讲ArrayList看做是长度可以变化的数组。

ArrayList：集合的底层是使用一个数组来保存元素，在增加或者删除指

定位置的元素时，会导致创建新的数组，效率比较低，因此不适合大量的

增删操作。允许通过索引的方式来访问元素，ArrayList集合查找元素和

便捷。

●LinkedList:该集合内部维护一个双向循环链表，链表中的每一个元素都

使用引用方式来记住它的前一个元素和后一个元素，从而可以将所有的元

素链接起来。

●

●

●

●

五、问题：

1、throws 和 throw的区别？

用户程序自定义的异常和应用程序特定的异常，必须借助于throws和throw语句定义抛出的异常。

●Throw是语句抛出的异常。语法：throw(异常对象) throwe;

●Throws是方法可能抛出的异常的声明，(在声明该方法是可能，该方法可能抛出

异常)

2、adaptor适配器

3、LinkedList及arraylist

4、collection

五、String类

5、1 String 类

1、用一个字符数组a创建String对象

char a*+=,‘g’,’o’,’o’,’d’-;

String s=new String(a); 等同于String s=new String(“good”);

2、String(char a[],int offset,int length)

提取字符数组a中的一部分创建一个字符对象。参数offset表开始截取字符的位置，length 表示截取字符串的长度。

列如：String s=new String(a,2,4) 表示在数组a中，从位置2开始截取长度为4的字符串。

3、String(char[] value)

该构造方法可分配一个新的String对象，使其表示字符数组中所有的元素链接的结果。

列如：char a[]=,‘s’,’t’,’u’,’d’,’e’,’n’,’t’-; String s=new String (a);

等同于String s=new String (“student”)

5、2、1链接多个字符串

String s1=new String (“hello”); String s2=new String(“world”);

String s=s1+” ”+s2;

System.out.println(s);

5、2、2链接其他数据类型

字符串也可以和其他数据类型链接。如果将这些字符串同这些数据类型链接，会将这些数据类型直接转换成字符串。

5、3 获取字符串的信息

5、3、1 获取字符串的长度

使用String 类的length()方法可以获取声明字符串对象的长度。

str.length();

String str = new String(“we are student”)

Int size=str.length();

上段代码是将字符串str的长度赋给int型变量size，此时size的长度为15，字符串的长度包括字符串中的空格。

5、3、2 字符串的查找

String类提供了两种查找字符串的方法，即indexOf()与lastIndexOf()这两种方法在字符串中所搜指定条件的字符或者字符串。

indexOf：返回的是所搜的字符首次出现的位置。

lastIndexOf：返回的是所搜的字符或者字符串最后一次出现的位置。

列如：String Str= “we are student”;

Int size = Str.indexOf(“a”);

5、3、3 获取指定位置的字符

使用charAt()方法可将指定索引处的字符返回。

Str.charAt(int index);

5、4 字符串操作

5、4、1 获取子字符串

通过String 类的substring()方法可对字符串进行截取。这些方法的共同点就是利用字符串的下标进行截取，且明确字符串下标是从0开始的。

substring()方法被两种不同的方法重载，来满足不同的需要。

(1)Substring(int beginindex):返回的是从指定的位置开始截取到该字符结尾的子串。

列如：String str=”Hello World”;

String substr=str.substring(3);

注意：字符串中空格占用一个索引位置。

(2)Substring(int beginIndex, int endIndex):该方法是从某一索引位置开始截取至某一索引

位置结束的子串。

5、4、2 去除空格

trim()方法返回字符串的副本，忽略前导空格和尾部空格

str.trim()去除空格后的长度str.trim().length();

5、4、3 字符串替换

str.replace(char oldChar,char newChar)

列如：String str=”address”;

String newstr=str.replace(“a”,”A”);

5、4、4 判断字符串的开始于结尾

startsWith()方法与endsWith()方法分别用于判断字符串是否以指定的内容开始或者结束。

这两种方法的返回值都是boolean类型。

1、startsWith()：该方法用于判断当前的字符对象的前缀是否是参数指定的字符串。

2、endsWith(): 该方法用于判断当前字符串是否是以给定的字符串结束。

5、4、5 判断字符串是否相等

Equals() ：如果两个字符串具有相同的字符和长度，则使用equals方法进行比较时，返回true。

注意：equals在比较时时区分大小写的。

用法：str.equals(String otherstr)

equalsIgnoreCase()方法：忽略大小写的情况下比较两个字符串是否相等。

5、4、6 按照字典顺序比较两个字符串

compareTo()方法为按照字典顺序比较两个字符串，该比较基于字符串各个字符的Unicode值，按照字典顺序将此String对象表示的字符列与参数字符串所表示的字符列进行比较。

compareTo()方法只有在equals(object)方法返回true时才返回0.

5、4、7 字母大小写转换

toLowerCase()方法：该方法将String转换为小写。str.toLowerCase()

toUpperCase()方法：该方法将String转换成大写。Str.toUpperCase()

5、4、8 字符串分割

使用split()方法可以使字符串按照指定的分割字符或者字符串对内容进行切割，并将分割后的结果存放在字符串数组中。Split()方法提供了两种重载的形式。

1、split(String sign) 该方法可根据给定的分隔符对字符进行拆分

sign为分割字符串的分割符。也可以使用正则表达式。

2、split(String sign,int limit):sign:分割符limit：为分割的次数。

5、5 格式化字符串

String类的静态format()方法用于创建格式化的字符串。Format()方法有两种重载形式。

1、format(String format,Object …args):使用指定格式的字符串和参数返回一个格式化字

符串，格式化后的新字符串使用本地默认的语言环境。

2、format(Local l,String format,Object …args):

L:格式化过程中要应用的语言环境。如果为NULL，则不进行本地化。

Format:格式字符串。

Args：格式字符串中由格式说明符引用的参数。

5、5、1日期和时间字符串格式化

1、日期格式化

Date date=new Date();

String s = String.format(“%te”,date);

%te:表示一个月中的某一天（1到31）

5、6使用正则表达式

5、7 字符串生成器

创建成功的字符串对象，其长度是固定的，内容不能被改变和编译。虽然使用”+”可以达到附加新字符或字符串的目的，但“+”回产生一个新的String实类，会在内存中创建新的字符串对象。如果重复的对字符串进行修改，将极大地增加系统的开销。可以使用String-Builder 类，大大提高频繁增加字符串的效率。

注意：如果在程序中频繁的附加字符串，建议使用String-builder，新创建的String-builder 对象初始容量是16个字符。可以自行指定初始的长度。如果附加的字符超过可容纳的长度，则StringBuilder对象将自动增加长度以容纳被附加的字符。若要使用StringBuilder最后输出

字符串结果，可以使用toString()方法。利用StringBuilder类中的方法可动态的执行添加，删除和插入等字符串的编辑操作。

1、append()方法：该方法用于向字符串中添加内容，通过该方法的多个重载形式，可以

接受任何类型的数据，如int，boolean，char，String，double

2、Insert(int offset，arg)方法：该方法用于向字符串生成器中的指定位置插入数据内容。

通过该方法的不同的重载形式，可以实现向字符串生成器中插入int，float，char，

和boolean等基本数据内容或其他数据对象。

3、Delete(int start,int end)方法

6、1 数组的概述

6、2、1 创建一维数组

6、4、2 填充替换数组元素

数组中的元素定义完成后，可以同过Arrays类的静态方法fill()来对十足中的元素进行替换。该方法可以通过各种重载的形式可以完成任意类型的数组元素的替换。Fill()方法有两种参数的形式。

1、fill(int [] a, int value):该方法可以将指定的int值分配给int型数组的每一个元素。

Int[] a:要进行元素替换的数组

Value：要存储数组中所有元素的值

2、fill(int[] a,int fromIndex,int toIndex,int value):该方法将指定的int值分配给int型数组指定范

围中得每个元素。填充的范围从索引fromIndex(包括)到toindex(不包括)。如果fromIndex== toIndex，则填充的范围为空。

6、4、3 对数组进行排序

通过Arrays类的静态sort()方法可以实现对视的排序。Sort()方法提供了多种的重载形式，可以对任意的数组进行升序排序。

Arrays.sort(object):object是指进行排序数组的名称。

Java 中的String类型数组的排序算法是根据字典编排顺序排序的，因此数字排在字母前面，大写字母排在小写字母的前面。

6、4、4复制数组

Arrays类的copyOf()方法与copyOfRange()方法可以实现对数组的复制。

copyOf()方法是复制数组至指定的长度，

copyOfRang()方法则是将指定的数组复制到一个新数组中。

1、copyOf(arr,int newlength):

arr:要进行复制的数组。

Newlength：Int型常量，复制新数组的长度。如果新数组的长度大于数组arr的长度，则用0来进行填充，char则用Null进行填充。如果截取的长度小于数组arr的长度，则会从数组arr的第一个元素开始截取满足新数组的长度为止。

2、copyOfRang(arr,int fromindex,int toIndex)：

arr；要进行复制的数组。

fromIndex：指定开始复制数组的索引位置。

toIndex:要复制范围的最后索引的位置。可大于数组arr的长度。新数组不包括索引时toIndex的元素。

6、4、5 数组查询

Arrays类的binarySearch()方法，可以使用二分法搜索法搜索指定的数组，以获得指定的对象。该方法返回要搜索元素的(int)索引值。BinarySearch()提供了多种重载形式。

1、binarySearch(object[]a.object key):a:要搜索的数组。Key：要搜索的值。

2、binarySearch(object[]a.,int fromIndex,int toIndex,Object key):a:要搜索的数组。Key：要搜索

的值。fromIndex:指定范围的开始索引(包含)，toIndex：指定范围的结束出索引(不包含) 6、5 数组排序算法

冒泡排序算法：

基本思想：冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素的值，把较小的元素移动到数组前面，把交大的元素移动大数组的后面。

Public class BubbleSort{

public static void main(String args[]){

//创建一个数组，这个数组元素是乱序的

int[] array={63,2,24,56,30,15};

//创建冒泡排序方法将数组排序

BubbleSort sorter=new BubbleSort();

//调用排序方法将数组进行排序

Sorter.sort(array);

}

public void sort(int[] array){

for(int i=1;i

for(int j=0;j

if(array[j]>array[i+1]){

int temp=array[j];

array[j]=array[j+1];

array[j+1]=temp;

}

}

}

showArray(array);

}

Public void showArray(int[] array){

For(int i:array){

System.out.print(“>”+i)

}

System.out.println();

}

}

6、5、2直接选择排序

直接选择排序方法属于选择排序的一种，它的速度要比冒泡排序快一些，也是常用的方法。

1、基本思想

是将指定的排序位置与其他数组元素分别进行对比，如果满足条件就交换元素的值，与冒泡排序相比，直接选择排序的交换次数要少的多，所以速度要快的多。

算法示例：

每一趟从待排序的数据元素中选取最小（或最大的）的一个元素，顺序地放在已经排好序的数列的最后面，直到全部待排序的数据元素排完。

算法实现：

Public class SelectSort{

Public static void main(String[] args){ Int[] array={63,4,24,1,3,15};

SelectSort sorter = new SelectScort(); Sorter.sort(array);

}

Public void sort(int[] array){

Int index;

For(int i=1;i

Index=0;

For(int j=1;j<=array.length-i;j++){

If(array[j]>array[index]){

Index=j;

}

Int temp=array[array.length-i];

array[array.length-i]=array[index];

array[index]=temp;

}

showArray(array);

}

Public void showArray(int[] array){ For(int i:array){

System.out.ptint(“>”+i);

}

System.out.println();

}

}

}

6、5、3 翻转排序

1、基本思想

翻转排序的基本思想比较简单，也很好理解。其实现的思路就是把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素进行替换，以此类推，直到把所有的元素翻转替换。

在程序中可以通过==和equals()两种方式对字符串进行比较，但是这两种方式有明显的区别。Equals()方法用于比较两个字符串中的字符是否相等，==方法用于比较两个字符串对象的地址是否相等。

第七章：类和对象

封装性

所谓类的封装是指在定义一个类时，将类中的属性私有化，即使用private关键字来修饰，私有的类只能在它所在的类中被访问。为了能让外界方位私有的属性，需要提供一些使用public修饰的公有方法，其中包括获取属性的getXxx()方法和设置属性值得setXxx()方法。

构造方法

1、方法名与类名相同。

2、在方法名的前面没有返回值得类型。

3、在方法中不能使用return语句返回一个值。

Person类中定义了一个无参的构造方法person()，并且运行结果可以来看出，Person 类中的无参构造方法被调用了。

实例化person对象时会自动调用类的构造方法，“new person()”语句除了会实例化person对象，还会调用构造方法person().

类的继承：

累的继承是指一个现有类的基础上去构建一个新的类，构建出来的类被称为子类。现有的类被称为父类，子类会拥有父类所有可继承的属性和方法。在Java中，声明一个类继承另一个类，需要extends关键字。

在类的继承中，需要注意一些问题，具体如下：

1、在Java中只支持单继承，不允许多重继承，也就是说一个类只能有一个直接父类。

2、多个类可以继承一个父亲。

3、在Java中，多层继承是可以的，即一个类的父亲可以再去继承某另外父类。

4、在Java中，子类和父类是一种相对的概念，也就是说一个类是某个类父类的同时，

也可以成为另外一个类的子类。

重写父类方法

子类重写父类方法时，不能使用比父类中被重写的方法更为严格的访问权限，如父类中的方法时public的，子类的方法就不能为private的。

史上最全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.doczj.com/doc/f09473010.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编程基础知识点汇总及习题集》--答案

目录 第一章 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面向对象知识点总结

j a v a面向对象知识点总 结 Company Document number：WTUT-WT88Y-W8BBGB-BWYTT-19998

1 类和对象 类: 类是用来描述一类事物的共性内容的, 类是抽象的; 创建类,如何描述 属性功能 用变量来描述属性 用方法来描述功能 对象: 就是现实中具体的事物,对象是具体的; 创建对象 类名对象名 = new 类名(); 如何通过对象访问类中属性和方法呢 对象名.变量名 对象名.方法名(); 只要是new的对象,就是新创建的,就会在内存中开辟一段单独的空间匿名对象 创建的对象没有赋值给具体的变量; 所以给匿名对象的属性赋值是没有任何意义的; 匿名对象使用场景

1 调用方法 2 作为参数传递 3 添加进容器中 This 关键字 This. 类中的普通方法访问到的成员前边都有this.这个关键字This. 就代表当前对象, 普通方法, 创建对象调方法, 谁调用就代表谁 This(); 可以用来在构造函数中调用本类与之相对应的构造函数使用注意事项: 1 this() 只能是构造函数的第一条执行语句 2 this() 不能在构造函数之间相互调用 3 this() 不能调用自己 构造函数(方法) 构造函数的作用 用来给对象进行初始话的(初始化就是指给对象的各个属性赋值) 构造函数何时执行 对象一创建就会调用与之相对应的构造函数

构造函数语法 修饰符没有返回值类型类名(参数列表){ 具体执行的代码 } 构造函数自动添加 当一个类中我们没有明确指定构造函数的话,jvm会自动帮我们添加一个空参数的构造, 如果我们指定了,就不添加了 构造函数和普通函数的区别 执行时机不同 对象一创建就会调用与之相对应的构造函数 普通函数只有被调用才会执行 return 1 就是用来在方法中返回具体结果(结果类型必须和方法的返回值类型一致) 2 即便方法的返回值类型是void,方法中也可以出现 return; 3 构造函数中也可以有return关键字 成员变量和局部变量 1 作用范围不同, 成员变量是定义在类中的,在整个类中都起作用 局部变量是定义在方法中的,在所在代码块起作用

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编程基础知识点汇总及习题集》--答案

目录 第一章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的知识点归纳总结

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各知识点详细总结(毕向东笔记整理)

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后，会在当前目录下查找要运行的类文件；

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基础阶段复习题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() }

javaweb知识点总结

javaweb知识点总结 篇一：javaweb期末复习知识点整理 1、 Web应用概述 1. URL与URI URL: 统一资源定位器 URI：统一资源定位符 2. 常见HTML标签 3. 表单的处理 4. 静态文档与动态文档的概念：静态文档是一种以文件的形式存放在服务器端的文档，客户发出对该文档的请求，服务器返回这个文档。动态文档是指文档的内容可根据需要动态生成，又可分为服务器端动态文档和客户端动态文档技术。 5. Servlet概念：服务器端小程序，是使用ServletAPI 以及相关类编写的java程序，主要用来扩展web服务器的功能。 6. 处理404错误：查看给定的路径名是否正确，查看Servlet类文件是否在classes目录下，查看文件内容是否正确，查看tomcat是否启动 2、 Servlet技术模型 1. Servlet的API：包，包 Servlet接口及方法 :

1） public void init(ServletConfig config)：完成Servlet初始化并准备提供服务。容器传给该方法一个ServletConfig类型的参数。 2）public void service(ServletRequest req,ServletResponse res)throw ServletException,IOException：对每个客户请求容器调用一次该方法，它允许Servlet为请求提供响应。 3） public void destroy()该方法由容器调用，指示Servlet清除本身，释放请求的资源并准备结束服务。 4） public ServletConfig getServletConfig()返回关于Servlet的配置信息，如传递给init()方法的参数。 5） public String getServletInfo()返回关于Servlet 的信息，如作者，版本及版权信息。 ServleConfig接口作用及方法 HttpServlet类 :新的service方法，doGet，doPost HttpServletRequest接口及常用方法 HttpServletResponse接口及常用方法 2. Servlet的开发步骤 编写一个Servlet类 编译 部署 (1)在tomcat的虚拟目录下，创建Web目录

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基础知识详细整理(图文并茂深入浅出)

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.doczj.com/doc/f09473010.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期末知识点整理总结

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基础知识整理

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的。