JAVA基础知识点梳理(精简)

JAVA基础知识点梳理（重点笔记）

1、标识符规则

a)可以由字母、数字、下划线、美元符$组成，不能以数字开头

b)不能是java的关键字和保留字

c)严格区分大小写，且尽量见名知意

2、变量

public class test{

public static void main(String[] args){

String love="imooc";

System.out.println("变量love的内容是："+love);

love="i love imooc";

System.out.println("重新赋值后变量love的内容是"+love);

}

}

3、变量命名习惯：

a)第一个单词的首字母小写，其后单词的首字母大写（骆驼式），myAge

b)变量命名时，尽量简短且能清楚的表达变量的作用，见名知意，如stuName

Ps: java变量长度没有限制，但是严格区分大小写

4、数据类型

a)int ：4个字节

b)Double：8个字节

c)Float：4个字节float变量赋值在数值后添加字母f float he=12.2f;

d)Char：2个字节char 变量赋值使用单引号’’

e)Boolean：1个字节取值只能为：true和false

f)String ：引用数据类型

5、Java常量的应用：

a)Final 数据类型常量名=值；

b)常量名一般使用大写字符

6、逻辑运算符：

a)^：异或有且只有一个为true 则返回true

7、条件运算符：

a)() ? 正确表达式: 错误表达式

i.Eg: String str=(8>5)? “yes” : “no”

8、运算符优先级最高的是：（）

9、输出换行：System.out.println();

10、

//循环语句练习

package ttt;

public class test6 {

public static void main (String[] args){

int i=1;

int sum1=0;

for(;i<101;i++){

if((i%3)!=0){

sum1+=i;

}

}

System.out.println("100以内不可以被3整除的数之和为："+sum1);

}

}

11、System.out.println 换行

12、System.out.print 不换行

13、

package ttt;

import java.util.Scanner;

public class test8 {

public static void main (String[] args){

int i=1;

System.out.println("请键入一个9位以内的数：");

Scanner aa = new Scanner(System.in);

int bb=aa.nextInt();

aa.close();

for(;bb>9;i++){

bb=bb/10;

}

System.out.println("i 的值为"+i);

}

}

14、数组

a)声明数组：

i.数组类型[] 数组名；

ii.数组类型数组名[]；

b) 分配空间：

i. 数组名 =new 数据类型【数组长度】

Eg： socres = new int[5];

合并： int[] socres=new int[5];

c) int[] sorces={1,2,2,3};

等价于: int[] sorces=new int[]{1,2,2,3};

d) 数组名.length 获取数组的长度

e) arrays类操作java中的数组

1、排序：arrays.sort(数组名) (升序)

2、将数组转换为字符串：arrays.toString(数组名)；（可以实现把多个数组元素

连接在一起，元素中间用逗号和空格隔开）。

f) foreach形式的for语句使用：

for(int i : words){

System.out.print(i);

}

15、java中无参无返方法的调用

a)定义：public void show(){} 方法名字第一个词小写，之后首字母大写

b)调用：

i.创建类的对象

ii.对象名.方法名（）；

16、java中无参有返方法的调用

a)Public int show(){ return sum; }

b)注意：

i.如果方法的返回类型为void，则方法中不能使用return返回值

ii.方法的返回值最多只能有一个，不能返回多个值

iii.方法返回值的类型必须兼容

17、方法的重载：

a)必须是在同一个类中

b)方法名相同

c)方法参数的个数、顺序或类型不同

d)与方法的修饰符或返回值没有关系

18、随机数方法：（int）（Math.random()*100）不需要导包

19、类和对象：

a)类是模子，确定对象将会拥有的特征（属性）和行为（方法）

b)类是对象的模型，具有相同属性和方法的一组对象的集合

c)对象：

i.属性——对象具有的各种特征

ii.每个对象的每个属性都有特定值

d)类是抽象概念，仅仅是模板，比如“手机”；对象是一个具体的实体

e)所有的java程序都是以类class为组织单元，由属性和方法组成

f)Java对象使用步骤：

i.类名对象名=new 类名（）；

ii.Phone phone=new Phone()；

iii.引用属性：phone.screen=5;//给screen属性赋值5

iv.引用方法：phone.send();//调用send（）方法

20、成员变量和局部变量的区别

a)作用域不同

b)初始值不同

c)在同一个方法中，不允许有同名局部变量

d)两类变量同名时，局部变量具有更高的优先级

21、构造方法：

a)使用new+构造方法创建一个新的对象

b)构造方法是定义在java类中的一个用来初始化对象的方法

c)构造方法与类同名且没有返回值

v.构造方法的格式：public 构造方法名（）｛ //初始化代码｝

vi.Phone phone=new Phone()；

vii.构造方法的名字与类名相同

d)当没有指定构造方法是，系统会自动添加无参的构造方法

e)当有指定构造方法，无论是有参、无参的构造方法，都不会自动添加无参的构造方法

f)构造方法的重载：方法名相同，但参数不同的多个方法，系统自动选择

22、静态变量static：

a)Static可以修饰变量、方法、代码块

b)访问（引用）：类名.变量名 hello.haha

c)定义： public static String haha=”imoc”;

d)Public：表示公开的、公有的

23、静态方法：

a)访问：类名.方法名（）；

b)静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。

c)如果调用非静态成员，可以通过对象来访问

d)在普通的方法中可以直接访问同类的非静态变量和静态变量

e)静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。

24、程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。

25、面向对象的三大特性：封装、继承、多态

26、封装：

a)概念：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供

的方法来实现对隐藏信息的操作和访问

b)好处：只能通过规定的方法访问数据；隐藏类的实例细节，方便修改和实现

c)实现步骤：

i.修改属性的可见性：设为private ： private int a;

ii.创建getter/setter方法：用于属性的读写

iii.在getter、setter方法中加入属性的控制语句：对属性的合法性进行判断

iv.(其实就是通过调用方法去读写属性)

v.可以通过eclipse 中source菜单中select getters and setters to create

27、java中的包：

a)作用：管理java文件；解决同名文件冲突

b)定义包：package包名

i.必须放在java源程序的第一行

ii.包名间可以使用“.”隔开

iii.Eg:com.imooc.myclass‘；

c) 系统包：

https://www.sodocs.net/doc/c516656861.html,ng.（类）：包含java语言基础的类

Java.util.（类）：包含java语言中各种工具类

Java.io.（类）：只包含输入、输出相关功能的表

d) 包的使用：

I. 可以通过import关键字，在某个文件使用其他文件中的类。

Import com.imooc.music.myclass

Ii. Java中，包的命名规范是全小写字母拼音

Iii.使用的时候不但可以加载某个包下的所有文件，也可以加载某个具体子包下的所有文件

访问修饰符的总结

访问修饰符本类同包子类其他

private √

默认√√

protected √√√

public √√√√

28、this关键字：

a)代表当前对象

i.This.属性操作当前对象的属性

ii.This.方法调用当前对象的方法

b) 封装对象的属性的时候经常会使用this关键字

29、java中的内部类：（包含内部类的类称为外部类）

a)内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其

他类访问该类

b)内部类的方法可以直接访问外部类的所有数据，包括隐私的数据

c)内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便

d)内部类可以分为：

i.成员内部类

1.内部类中定义的方法可以直接访问外部类中的数据，不受访问控制符的影响

2.定义一个内部类对象：内部类对象名 =外部类对象.new 内部类（）

3.外部类不能直接使用内部类的成员和方法，可以先创建内部类的对象，然后

通过内部类的对象来访问其他成员变量和方法

4.外部类和内部类具有相同的成员变量或方法，则内部类默认访问自己的成员

变量或方法，如果要访问外部类的成员变量，可以使用this关键字ii.静态内部类

1.静态内部类不能直接访问外部类的非静态成员，但可以通过new外部类（）.

成员的方式访问

2.如果外部类的静态成员与内部类的成员名称相同，可以通过“类名.静态成员”

访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不同，

则可以通过“成员名”直接调用外部类的静态成员

3.创建静态内部类的对象时，不需要外部类的对象，可以直接创建内部类对

象名=new 内部类（）；

iii.方法内部类

1.方法内部类就是定义在外部类的方法中，方法内部类只在该方法的内部可见，

即只在该方法内可以使用。

2.由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能

使用访问控制符和static修饰符

iv.匿名内部类

30、继承：

a)Java里都是单继承

b)好处：

i.子类直接拥有父类的所有属性和方法，但private除外

ii.实现代码的复用

iii.Class 子类 extends 父类

c)Final关键字

i.修饰类：则该类不允许被继承

ii.修饰方法：则该方法不允许被覆盖（重写）

iii.修饰属性：则该类的属性不会进行隐式的初始化（类的初始化属性必须有值）或在构造方法中赋值

iv.修饰变量，则变量的值只能赋一次，即常量

d)Super关键字

i.在对象的内部使用，可以代表父类对象

ii.方位父类的属性，或方法， super.age super.eat()

31、Object类：

a)Object类是所有类的父类，如果一个类没有使用extends关键字明确标识继承另一

个类，那么这个类默认继承object类

b)Object类中的方法，适合所有子类

c)方法：

i.toString()方法：

1.在object类里面定义的tostring()方法的时候返回的对象的哈希码（对象

地址字符串）（用来区分对象）

2.如：直接输出dog对象的值：System.out.println(dog);

3.生成：source菜单栏——>generate toString()——>生成输出属性的方

法

ii.Equals()方法：

1.比较的是对象的引用是否指向同一块内存地址：Dog dog=new Dog();

2.生成：source菜单栏——>generate hashcode()and equals()...

a)类对象：姓名、年龄、身高...obj.getclass()

b)类的对象：小灰、25、170...obj

3.调用：if(dog1.equals(dog2))——>判断两个对象是否相同

32、多态：（继承是多态的基础）

a)引用多态：

i.父类的引用可以指向本类的对象：animals obj1=new animals();

ii.父类的引用可以指向子类的对象: animals obj2=new dog();

iii.注意：子类的引用不可以指向父类的对象:dog obj3=new animals();

b)方法多态：

i.创建本类对象时，调用的方法为本类方法

ii.创建子类对象时，调用的方法为子类重写的方法或者继承的方法

33、多态中的引用类型转换

a)向上类型转换（隐式/自动类型转换），是小类型到大类型的转换，无风险

b)向下类型转行（强制类型转换），是大类型到小类型的转换，有风险，溢出

c)Instanceof 运算符，来解决引用对象时的类型，避免类型转换的安全问题

i.Eg:

Dog dog=new Dog();

Animal anmal=dog;//自动类型提升，向上类型转换

Dog dog2=(Dog)animal;//强制类型转换，向下类型转换

Cat cat=(Cat)animal;//编译时Cat类型；运行时Dog类型，报错

可以替换为：

if (animal instanceof Cat){

Cat cat=(Cat)animal;

}

34、抽象类：

a)语法：抽象类前使用abstract关键字修饰，则该类为抽象类

b)作用：限制规定子类必须实现某些方法，但不关注实现细节

c)规则：

i.Abstract定义抽象类

ii.Abstract定义抽象方法，只有声明，不需要实现

iii.包含抽象方法的类是抽象类

iv.抽象类中可以包含普通的方法，也可以没有抽象方法

v.抽象类不能直接创建，可以定义引用变量

d) 现有Shape图形类，用Rectangle矩形和Circle圆形子类，求图形的周长和面积：

Shape.java:

package com.amooc;

public abstract class Shape{

public abstract void zhouchang(double l,double w);

public abstract void mianji(double l,double w);

public abstract void zhouchang2(double r);

public abstract void mianji2(double r);

}

Rectangle.java:

package com.amooc;

public class Rectangle extends Shape {

public void zhouchang(double l,double w){

double z;

z=2*(l+w);

System.out.println("长为："+l+" ,宽为："+w+" ,的长方形周长是："+z);

}

public void mianji(double l,double w){

double m;

m=l*w;

System.out.println("长为："+l+" ,宽为："+w+" ,的长方形面积是："+m);

}

public void zhouchang2(double r){

double z;

z=2*3.14*r;

System.out.println("半径为："+r+" ,的圆形周长是："+z);

}

public void mianji2(double r){

double m;

m=3.14*r*r;

System.out.println("半径为："+r+" ,的圆形面积是："+m);

}

}

imooc1.java:

package com.amooc;

public class imooc1{

public static void main(String[] args){

Rectangle z1=new Rectangle();

Shape m1=new Rectangle();

Shape z2=new Rectangle();

Shape m2=new Rectangle();

z1.zhouchang(3,4);

m1.mianji(3,4);

z2.zhouchang2(3);

m2.mianji2(3);

}

}

35、接口：

a)概念：接口可以理解为一种特殊的类，由全局常量和公共的抽象方法所组成。类是一

种实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，

也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法

b)定义：和类定义不同，定义接口不再使用class关键字，而是使用interface关键字

c)基本语法：[修饰符] interface 接口名 [extends 父接口1,父接口2...]

{

零个到多个常量定义

零个到多个抽象方法的定义

}

接口是用来被继承、被实现的，修饰符一般建议用public

注:不能使用private和protected修饰接口

d)接口定义常量：接口中的属性是常量，即使定义时不添加 public static final修

饰符，系统也会自动加上

e)接口定义方法：接口中的方法只能是抽象方法，总是使用，即使定义时不添加public

abstract ，系统也会自动加上

f)使用接口1：

i.一个类可以实现一个或多个接口，实现接口使用implements关键字，java中一

个类只能继承一个父类是不够灵活的，通过实现多个接口可以做补充ii.继承父类实现接口的语法为：

[修饰符] class 类名 extends 父类 implements 接口1，接口2...

{

类体部分//如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法...

}

如果要继承父类，继承父类必须在实现接口之前

Eg: new interface Ijiekou （命名习惯，名字前加大写I）

g)使用接口2：

i.接口在使用过程当中，还经常与匿名内部类配合使用，匿名内部类就是没有名字

的内部类，多用于关注实现而不关注实现类的名称

ii.语法格式：

Interface i=new Interface(){

public void method(){

System.out.println(“匿名内部类实现接口的方式”);

}

};

注意：末尾以分号结束

或：

new Interface(){

Public void playGame(){

System.out.println(“使用匿名内部类的方式实现接口”);

}

}.playGame();

h)在接口中定义方法geta(),正确的格式是：void geta();

注：接口方法不能有方法体，同时方法的访问修饰符不能为private和protected 36、UML：（unified modeling language),又称统一建模语言或标准建模语言。是一个支持模型化和软件系统开发的图形化语言，为软件开发的所有阶段提供模型化和可视化支持。

a)用例图：（the use case diagram)

i.用例图能够以可视化的方式，表达系统如何满足所收集的业务规则，以及特定的

用户需求等信息

b)序列图：（the sequence diagram)

i.序列图用于按照交互发生的一系列顺序，显示对象之间的这些交互

用户

表明身份

请求取钱

确认并取款

授权合法

柜台窗口点帐窗口取钱账户后台

分发货币

c)类图：（the class diagram）

i.UML类图业务逻辑和所有支持结构一同被用于定义全部的代码结构

d)UML建模工具：

i.Visio、rational rose、powerdesign

37、综合练习：答答租车系统

a)功能：

i.展示所有可租车辆

ii.选择车型、租车量

iii.展示租车清单，包含：总金额、总载货量及其车型、总载人量及其车型

b)项目分析：

i.数据模型分析

1.通过对现实世界的事与物主要特征的分析、抽象，为信息系统的实施提供数

据存取的数据结构以及相应的约束

2.数据结构的组成：操作（方法）、属性

ii.业务模型分析

iii.显示和流程分析

38、异常：走路被树叶绊倒，吃糖饼烫后脑勺，考试快交卷了才发现反面还有题...

a)组织图：

Throwable

Error Exception

虚拟机错误内存异常RuntimeException检异常查

文件异常SQL异常

空指针异常数组下标越界异常类型转换异常算术异常

b)处理异常：

i.try-catch 以及try-catch-finally

ii.Eg:

Try{

//一些会抛出异常的方法

}catch(Exception e){

//处理该异常的代码块

}finally{

//最终将要执行的代码

}

iii.

package com.imooc0325;

public class test1{

/*

divide：除数

result：结果

try-catch捕获while循环

每次循环，divide减1，result=result+100/divide

如果：捕获异常，打印输出"抛出异常了！！！"，返回-1

否则：返回result

*/

public int test(){

int divide =10;

int result =100;

try{

while(divide>-1){

divide--;

result =result+100/divide;

}

return result;

}catch(Exception e){

e.printStackTrace();//打印异常具体信息

System.out.println("循环抛出异常了！！！");

return -1;

}finally{

System.out.println("我还会回来的~~");

}

}

public static void main(String[] args){

test1 tct=new test1();

int result=tct.test();

System.out.println("test方法执行完毕，返回值："+result);

}

}

c)如果三个程序块之内都没有return语句，则调用程序块外的return语句

d)Java中的异常抛出以及自定义异常

i.Java中的异常抛出：

1.throw ：将产生的异常抛出

2.throws：声明将要抛出何种类型的异常（声明）

public void 方法名（参数列表）

throws 异常列表｛

//调用会抛出异常的方法或者：

throw new Exception();

｝

ii.自定义异常：

1.class 自定义异常 extends 异常类型｛｝

2.Public class DrunkException extends Exception{

Public DrunkException(String message){}

}

e)JAVA中的异常链：

/*

test1()：抛出“喝大了”异常

test2()：调用test1(),捕获“喝大了”异常，并且包装成运行时异常，继续抛出

main方法中，调用test2(),尝试捕获test2()方法抛出的异常

*/

public void test1() throws DrunkException{

throws new DrunkException("喝车别开酒")；

}

public void test2() {

try{

tset1();

}catch(DrunkException e){

RuntimeException newExe=new RuntimeException("司机一滴酒，亲人两行泪~~")；

newExe.initCause(e);

throw newExe;

}

}

public static void main(String[] args){

chaintest ct=new chaintest();

try{

ct.tset2();

}catch(Exception e;)

e.printStackTrace();

}

}

注：捕获到的异常，可以在当前方法的catch块中处理，也可以抛出给调用者去处理

39、实用中的经验与总结：

a)处理运行时异常时，采用逻辑去合理规避，同时辅助try-catch处理

b)在多重catch块后面，可以加一个catch（Exception)来处理可能会被遗漏的异常

c)对于不确定的代码，也可以加上try-catch，处理潜在的异常

d)尽量去处理异常，切忌只是简单的调用printStackTrace()去打印输出

e)具体如何去处理异常，要根据不同的业务需求和异常类型去决定

f)尽量添加finally语句块去释放占用的资源

40、JAVA中的字符串：在java中，字符串被作为String类型的对象处理。String类位于https://www.sodocs.net/doc/c516656861.html,ng包中。默认情况下，该包被自动导入所有的程序

a)String s1=“imooc”; //创建一个字符串对象imooc,名为s1

b)String s2=new String(); //创建一个空字符串对象，名为s2

c)String s3=new String(“imooc”); //创建一个字符串对象imooc，名为s3

41、java中字符串的不变性：String对象创建后则不能被修改，是不可变的，所谓的修改其实时创建了新的对象，所指向的内存空间不同

a)其实质是创建了新的字符串对象

b)一旦一个字符串在内存中创建，则这个字符串将不可改变

42、java中String类的常用方法

a)String类提供了许多用来处理字符串的方法

处理字符串的方法

1 int length() 返回当前字符串的长度

2 int indexOf(int ch) 查找ch字符子该字符串中第一次出现的位置

3 int indexOf(String str) 查找str子字符串在该字符串中第一次出现的位置

4 int lastIndexOf(int ch) 查找ch字符在该字符串中最后一次出现的位置

5 int lastIndexOf(String str) 查找str子字符串在该字符串中最后一次出现的位置

6 String substring(int beginIndex) 获取从beginIndex位置开始到结束的字符串

7 String substring(int beginIndex,int

endIndex)

获取从beginIndex位置开始到endIndex位置的子字符串中

8 String trim() 返回去除了前后空格的字符串

9 boolean equals(Object obj) 将该字符串与指定对象比较，返回ture或false

10 String toLowerCase() 将字符串转换为小写

11 String toUpperCase() 将字符串转换为大写

12 char charAt(int index) 获取字符串中指定位置的字符

13 String[] split(String regex,int limit) 将字符串分割为子字符串，返回字符串数组

14 byte[] getBytes() 将该字符串转换为byte数组

b)字符串str中字符的索引从0开始

c)使用indexOf进行字符或字符串查找时，如果匹配返回位置索引；如果没有匹配结果，

返回-1

d)使用substring（beginIndex,endIndex)进行字符串截取时，包括beginIndex位

置的字符，不包括endIndex位置的字符

e)

package com.imooc0325;

import java.util.Arrays;

public class test2 {

public static void main(String[] args){

//定义一个字符串“学习一下java编程”

String str ="学习一下java编程";

//打印出字符串长度

System.out.println("字符串长度："+str.length());

//查找字符‘编’的位置

char c='编';

System.out.println("字符'编'的位置："+str.indexOf(c));

//查找字符串'JAVA'的位置

System.out.println("子字符串'java'的位置：

"+str.indexOf("java"));

//查询子字符串'imooc'的位置，如果找不到返回-1

System.out.println("子字符串'imooc'的位置：

"+str.indexOf("imooc"));

//按空格把字符串拆分成一个数组，并输出数组元素

String[] arr=str.split(" ");

System.out.print("按空格拆分成数组："+Arrays.toString(arr));

System.out.println();

//获取索引位置[4,8)之间的字符串

System.out.println("获取位置[4,8)之间的子符串："+str.substring(4,8));

}

}

43、==和equals()的区别：

a)==：判断两个字符串在内存中首地址是否相同，即判断是否是同一个字符串对象

b)equals()：比较存储在两个字符串对象中的内容是否一致

//定义一个字符串“学习JAVA 编程”

String str="学习JAVA 编程";

//将字符串转换为小写

System.out.println("转换为小写："+str.toLowerCase());

//获取索引位置为1的字符

System.out.println("获取索引为1位置的字符："+str.charAt(1));

//将字符串转换为byte[]，并打印输出

byte[] b=str.getBytes();

System.out.print("转换为字符数组：")；

for(int i=0;i

System.out.print(b[i] + " ");

}

System.out.println();

//和另一个字符串“学习JAVA 编程”进行比较

String str2 =new String("学习JAVA 编程")；

System.out.println("str和str2的内存地址相同？"+(str == str2));

System.out.println("str和str2的内容相同？"+str.equals(str2));

44、定义字符串可以使用：

a)String

b)StringBuilder:性能更高，优先使用

c)StringBuffer：是线程安全的

d)创建一个空对象：StringBuilder str1=new StringBuilder();

e)创建字符串为“imooc”：StringBuilder str2=new StringBuilder(“imooc”);

f)

//创建StringBuilder对象，存储字符串

StringBuilder str =new StringBuilder("hello");

str.append(" imooc");//在字符串后面追加字符串

str.append(520);//在字符串后面追加整数

System.out.println("字符串长度："+str.length());//字符串长度

System.out.println("插入前，"+str);

str.insert(11,"!");//在指定位置插入内容

String str2 =str.toString();//转换为String对象

System.out.println("插入后："+str2);

45、java中的包装类：

a)基本类型不能调用方法，功能简单。为了让基本数据类型也具备对象的特性，java

为每个基本数据类型都提供了一个包装类，这样我们就可以像操作对象那样来操作

基本数据类型。

b)包装类主要提供了两大类方法：

i. 将本类型和其他基本类型进行转换的方法 ii. 将字符串和本类型及包装类互相转换的方法 c) 基本类型

和包装类型之间的对应

关系：

d) Integer 包装类的构造方法：

i. Integer(int value)：创建一个Integer 对象，表示指定的int 值

ii. Integer(String s)：创建一个Integer 对象，表示String 参数所指示的int 值 iii. int i=2;//定义int 类型变量，值为2

Integer m= new Integer(5);//定义Integer 包装类对象，值为5 Integer n=new Integer(“8”);//定义Integer 包装类对象，值为8

e) Integer 包装类的常用方法：

46、java 中基本类型和包装类之间的转换

a) Integer a =new Integer(3); //定义Integer 包装类对象，值为3

int b=a+5; //将对象和基本类型进行运算 b) 装箱：

int i=10; //定义一个int 基本类型值 Integer x =new Integer(i); //手动装箱 Integer y =i; //自动装箱 c) 拆箱：

Integer j=new Integer(8); //定义一个integer 包装类对象，值为8 int m=j.intValue(); //手动拆箱为int 类型 int n=j; //自动拆箱为int 类型

序号 基本类型 对应的包装类 1 byte Byte 2 short Short 3 int Integer 4 long Long 5 float Float 6 double Double 7 char Character 8

boolean

Boolean

返回值 方法名 解释 byte byteValue() 将该Integer 转为byte 类型

double doubleValue() 转为double 类型

float floatValue() 转为float 类型

int intValue() 转为int 类型

long longValue() 转为long 类型 static int parseInt(String s) 将字符串转换为int 类型 String toString() 转为字符串类型 static Integer valueOf(String s) 将字符串转换为Integer 类型

47、java中基本类型和字符串之间的转换

a)基本类型转换为字符串有三种方法：

i.使用包装类toString()方法

ii.使用String类的valueOf()方法

iii.用一个空字符串加上基本类型，得到的就是基本类型数据对应的字符串Int c=10;

String str1=Integer.toString(c); //方法一

String str2=String.valueOf(c); //方法二

String str3=c+””; //方法三

b)将字符串转换成基本类型有两种方法

i.调用包装类的parseXxx静态方法

ii.调用包装类的valueOf方法转换为基本类型的包装类，会自动拆箱

String str=”8”;

int d=Integer.parseInt(str); //方法一

int e=Integer.valueOf(str); //方法二

48、使用Date和SimpleDateFormat类表示时间

a)获取当前时间：Date类

Date d=new Date(); //使用默认的构造方法创建Date对象

System.out.println(d); //输出Date对象（显示当前时间）

b)格式化日期和时间：SimpleDateFormat类

i.使用format()方法将日期转换为指定格式的文本

//创建Date对象，表示当前时间

Date d=new Date();

//创建SimpleDateFormat对象，指定目标格式

SimpleDateFormat sdf=new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);

//调用format()方法，格式化时间，转换为指定格式的字符串

String today =sdf.format(d);

//输出转换后的字符串

System.out.println(today);

ii.使用parse()方法将文本转换为日期

//创建日期格式的字符串

String day=”2016年3月27日15:30:33”;

//创建SimpleDate.Format对象，指定字符串的日期格式

SimpleDateFormat df=new SimpleDateFormat(“yyyy年MM月dd日HH：mm:ss”);

//调用parse()方法将字符串转换为日期

Date date=df.parse(day);

//输出转换后的时间

System.out.println(“当前时间：”+date);

iii.导包：

1.Import java.text.parseexception;

2.Import java.text.simple.date.format;

3.Import java.util.date;

49、Calendar类的应用（相比Date更好~~~）

a)包：java.util.Calendar

//获取年月日、时间信息

package com.imooc0327

import java.util.Calendar;

public class test2 {

public static void main(String[] args){

Calendar c =Calendar.getInstance();//创建Canlendar对象

int year =c.get(Calendar.YEAR);//获取年

int mouth =c.get(Calendar.MONTH)+1;//获取月份，0表示1月份

int day =c.get(Calendar.DAY_OF_MONTH);//获取日期

int hour =c.get(Calendar.HOUR_OF_DAY);//获取小时

int minute =c.get(Calendar.MINUTE);//获取分钟

int second =c.get(Calendar.SECOND);//获取秒

System.out.println("当前时间："+year+"-"+mouth+"-"+day+"

"+hour+":"+minute+":"+second);

}

}

50、使用Math类操作数据

a)所有方法都是静态方法，可以直接使用类名.方法名

b)常用方法：

i.long : round() , 返回四舍五入后的整数

ii.double : floor() , 返回小于参数的最大整数

iii.Double ：ceil() , 返回大于参数的最小整数

iv.Double ：random() , 返回[0,1)之间的随机数浮点数

c)实例：

package com.imooc0327;

public class test3 {

public static void main(String[] args){

double a=12.21; //定义一个double类型的变量

int b=(int)a; //将double类型强制转换为int类型，去掉小数点

System.out.println("强制类型转换："+b);

long c=Math.round(a); //调用一个round方法，进行四舍五入

System.out.println("四舍五入："+c);

double d=Math.floor(a); //调用floor方法，返回小于参数的最大整数

System.out.println("floor:"+d);

double e=Math.ceil(a); //调用ceil方法，返回大于参数的最小整数

System.out.println("ceil:"+e);

double x=Math.random(); //调用random方法，产生[0,1)之间的随机数浮点数

System.out.println("随机数"+x);

int y=(int)(Math.random()*99); //产生[0,99)之间的随机整数

System.out.println("产生[0,99)之间的随机整数："+y);

}

}

51、java中的集合框架：

a)Java的集合分为：

i.Set：无序、不可重复的集合

ii.List：有序、重复的集合

iii.Map：具有映射关系的集合

iv.Queue：队列集合的实现

b)集合类概述：为了保存数量不确定的数据，以及保存具有映射关系的数据，java提供

集合类。集合类主要负责保存、盛装其他数据，因此集合类也被成为容器类。所有的

集合类都位于java.util包下。

c)集合类和数组不一样，数组元素既可以是基本类型的值，也可以是对象（实际是对象

的引用变量）；而集合里只能保存对象（实际也是引用变量）。

d)Java的集合类主要由两个接口派生而出：collection和map

e)Map保存的每项数据都是key-value对，也就是由key和value两个值组成

f)Collection接口是list、set、queue接口的父接口，该接口里定义的方法既可以

用于操作set集合，也可以用于操作list和queue集合。Collection接口里定义了如下操作集合元素的方法：添加元素、删除元素、返回collection集合的元素个数以及清空整个集合

i.boolean add(Object o)：该方法用于向集合里添加一个元素。如果集合对象被

添加操作改变了则返回true

ii.boolean addAll(Collection c)：该方法把集合c里的所有元素添加到指定集合里。如果集合对象被添加操作改变了则返回true

iii.void clear()：清除集合里的所有元素，将集合长度变为0

iv.boolean contains(Object o)：返回集合里是否包含指定元素

v.boolean containsAll(Object o)：返回即集合里是否包含集合c里的所有元素

vi.boolean isEmpty()：返回集合是否为空。当集合长度为0时返回true，否则返回false

vii.Iterator iterator()：返回一个Iterator对象，用于遍历集合里的元素viii.boolean remove（Object o)：删除集合中指定元素o，当集合中包含了一个或多个元素o时，这些元素将被删除，该方法将返回true

ix.boolean removeAll(Collection c)：从集合中删除集合c里包含的所有元素（相当于用调用该方法的集合减集合c），如果删除了一个或一个以上的元素，

该方法返回true

x.boolean retainAll(Collection c)：从集合中删除集合c里不包含的元素（相当于取得把调用该方法的集合变成该集合和集合c的交集），如果该操作改变了

调用该方法的集合，该方法返回true

xi.int size()：该方法返回集合里元素的个数

xii.Object[] toArray()：该方法把集合转换成一个数组，所有集合元素变成对应的数组元素

g)Iterator接口也是java集合框架的成员，但它与collection系列、map系列的集

合不一样。Collection、map主要用于盛装其他对象，而iterator则主要用于遍历collection集合中的元素，iterator对象也被称为迭代器。它向应用程序提供了遍历collection集合元素的统一编程接口，iterator接口里定义了如下三个方法：

i.boolean hasNext():如果被迭代的集合元素还没有被遍历，则返回true

ii.Object next()：返回集合里下一个元素

iii.void remove()：删除集合里上一次next方法返回的元素

h)set集合：实际上与collection相同，只是行为不同，set不允许包含重复元素。如

果试图把两个相同元素加入同一个set集合中，则添加操作失败，add方法返回false，且新元素不会被加入

i)三个实现类：

i.HashSet是Set接口的典型实现，大多数使用Set集合时就是使用这个实现类。

HashSet按Hash算法来存储集合中的元素，因此具有很好的存取和查找性能。

HashSet集合判断两个元素相等的标准时两个对象通过equals方法比较相等，

并且两个对象的hashCode()方法返回值也相等

史上最全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.sodocs.net/doc/c516656861.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技术--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各知识点详细总结(毕向东笔记整理)

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期末知识点整理总结

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.sodocs.net/doc/c516656861.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知识点总结 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各知识点详细总结

基础知识总结 写代码： 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．JAVA的特点： ○1简单易用、完全面向对象； ○2与平台无关性、可扩展性强； ○3可移植性高、支持分布式编程； ○4健壮、安全可靠并性能优异； ○5支持多线程开发技术； ○6支持动态开发。 2.JVM：Java虚拟机（JVM是Java实现跨平台的基础）。 Java的源程序（*.java）编译（命令：java+文件名.java）Java字节码（*.class编译时自动形成，与源程序名一致) 运行（命令：java+源程序的文件名）JVM（Windows、Linux) 开发工具，Javac及基础核心类 JDK 运行环境，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 类：类名应该是名词，大小写混合，每个单词的首字母大写。 如：class AccountBook 接口：接口名的大小写应该与类名一样。 如：interface Account 方法：方法名应该动词，大小写混合，首字母小写。每个方法名中，以大写字母区分单词。限制使用下划线。

Java知识总结完整版

第1章 Java概述 Java语言的特特点 一种面向对象的语言；一种平台无关的语言；一种健壮的语言，吸收了C/C++的优点，但去掉了其影响程序健壮性的部分（如：指针、内存的申请与释放等） Java的两种核心机制 Java虚拟机（Java Virtual Machine） 垃圾回收机制（Garbage Collection） 源程序（*.java文件）→Java编译器→字节码（*.class文件）→类装载器→字节码校验器→解释器→操作系统平台 一次编译，随处运行 Java是一种解释型语言 JDK(Java Development Kit)软件开发工具包 JRE(Java Runtime Environment)运行时环境 开发需要JDK；用户只需JRE PATH:WINDOWS系统执行命令时要搜寻的路径（如javac.exe，java.exe）CLASSPATH:Java在编译和运行时要找的class所在路径（“.”代表当前路径） java：运行java程序 javac：编译java程序

java –version 一个源文件最多只能有一个public类，其他类数量不限，源文件名必须与public 类名一致 Java应用程序的执行入口时main（）方法：public static void main(String[] args){…} Java语言中严格区分大小写 编译后，每一个类都对应一个class文件 第2章基础语法 标示符由字母、下划线”_”、美元符”$”或数字组成 标示符应以字母、下划线、美元符开头 Java标示符对大小写敏感，长度无限制，注意“见名知意”且不能与Java语言关键字重名 goto和const虽然未使用，但也被作为Java的关键字保留