JAVA知识点汇总

关键字:对于编译器来说有特殊含义的单词

保留字:java已经征用了,但是,没有具体含义的单词,要用还没用的字,以后是否使用未定比如:goto等

标识符:java中的包名,类名,方法名,变量名,参数名统称标识符(自己起的名都是标识符)

规则:元素必须是数字,字母,下划线,$,其中数字不能开头

规范:

类名:每个单词首字母大写例如:

方法名,变量名,参数名:一个单词首字母小写;多个单词,第一个单词首字母小写,后面每个单词首字母大写.例如:getName

包名:每个字母都小写,中间用.分割例如:com.neudeu.demo

常量名:每个字母都大写例如:PI

* 变量:随时可以变化的量

* 定义变量:

数据类型变量名 = 值;

* 第一种 1.先声明

* 2.在赋值

* 第二种 1.声明并且赋值

* 常量:永远不变的量

数据类型:

* 基本数据类型

* 整数型:byte(1字节) short(2字节) int(4字节)(默认) long(8字节,定义long时默认将值赋给了int,在值后面加L即可)

* 浮点型:float(单精度浮点) double(双精度浮点)

* 字符型: char 16字节范围(0~65535) 通常情况是单引号中放一个字符,不放不行,放空格可以

* 布尔型:只有两个值 true false

* 引用数据类型

* 数组

* 类

* 接口

运算符和表达式

* 赋值运算符:=;+=;-=;*=;/=;%=

* 算术运算符:+,-,*,/,%,++,--

* 一元运算符:只有一个操作数的运算符 +4 -9 -7

* 二元运算算:有两个操作数的运算符 2+5 2*8

* /:除法中,除号两端都是整数,结果为向下取整的整数;两端有一端是小数,结果正常数学运算

* %:结果取余数:结果取余数,结果的正负号和被除数一样

* ++,--:变量在前时,先赋值在运算,先把c的值赋给了d,所以d=2;c在自增1,所以c=3

* 变量在后时,先运算在赋值,c2先增1在赋值给d,所以d=2;c2=2;

关系运算符(比较运算符)

* == != >= <= < >

* 逻辑运算符

* &&(短路效应) ||(短路效应) !

* &&和&的区别面试题

* &&:逻辑运算符,只能参与逻辑运算,具有短路效应,开发常用

* &:位运算符,不仅能参与逻辑运算还能参与位运算,不具备短路效应,开发不常用]

* 什么是短路效应

:如果符号左面表达式的结果可以作为整个表达式的结果,符号右边的表达式不执行.

(&&中,如果左面结果为false,发生短路效应,右面不用看)

三元运算符

* 表达式?值1:值2;

* 如果表达式为真 ,执行值1;表达式为假,执行值2

数据类型转换

* 自动类型转换:小-->大大小为数据类型的表数范围

* 强制类型转化:大-->小要有强制的动作小变量=(目标类型)大变量

swith:条件语句格式

swith(表达式){类型(byte,short,int,char,String)

case 值1:

执行语句;

break;

...

default:

执行语句:

break;

}

注意:case和default书写位置上没有要求,在执行上是有要求的,先执行case再执行default

case 后面的值不能重复,case后面的值不能是变量

常用功能:

随机数:Random:

作用:产生随机数

用法:

1.导包

2.固定写法

常用功能:

键盘录入Scanner(扫描器)

作用:将数据通过键盘录入到程序中

做法:

1.导包

2.固定写法

循环中断机制:

break和continue的区别面试题

break:结束整个循环,可以用在switch上

continue:结束本轮循环,进入下一轮,只能用在循环中

条件语句:满足就执行不满足不执行

单一条件:if语句

二选一条件:if else 语句

三选一或多轩一:if elseif else语句

数组:

可以存放数据的容器,类型一致,长度固定,不可改变

定义数组:

按照长度 1.先声明在赋值

int []arr=new int[3];

2.声明并赋值

按照内容:长度是元素的个数

方法的定义:

完成某个功能的一组语句

方法定义语法

1.有参数有返回值

2.有参数没有返回值

3.没有参数有返回值

4.没有参数没有返回值

递归方法:

一个方法体内调用它自身的方式

方法重载:

在一个类中,允许同时存在一个以上的同名方法,这些方法之间的关系称作重载

* 方法重载的规则:

* 方法名相同

* 参数列表不同(个数,类型,顺序不同)

* 与返回值类型无关

类:把相似的对象划归为一个类,抽象的概念

* 类里面包含:属性(事务特征:身高姓名性别) 方法(动作,行为:跑跳唱) 嵌套类(了解) 代码块(了解)

* 属性和局部变量对比:

* 位置:

* 属性:定义在类中,方法外;局部变量:定义在类中,方法体中

* 位置和使用顺序:

* 属性:定义在方法体上下都可以;局部变量:必须在使用之前声明并赋值才能使用

* 默认值:

* 属性:有默认值;局部变量:没有默认值

* 重名:

* 属性:可以重名;局部变量:可以重名通过this关键字区分,this后面是属性

创建对象:类名对象名 = new 类名()

* 访问属性:对象名.属性

* 访问方法:对象名.方法名

* 匿名对象

:没有对象名的对象

* new 类名();

* 什么时候使用:当方法或者属性只被访问一次的时候使用匿名对象

构造方法:

又称构造器,是用来创建对象的,还可以给属性赋值

* 书写构造方法的特点:

* 构造方法名必须与类名相同

* 不含返回值类型,也没有void

* 不能在方法中用return语句返回一个值

* 使用构造方法:创建对象

* 构造方法名对象名 =new 构造方法名();

* 注意:如果没有手动给出无参数构造方法,系统会,默认提供一个无参数构造方法,

* 一旦手动给出了构造方法,系统将不在提供默认的无参数构造方法

* 普通方法不能创建对象*它有默认的构造方法

* 构造方法才能创建对象*

静态:static修饰符

* 可以修饰:属性(静态属性)

* 方法(静态方法)

* 代码块 (静态代码块)

* 访问静态动态:属性和方法也可以通过对象的形式访问,通常不推荐

* 属性:类名.属性

* 方法:类名.方法

* 静态代码块:在创建对象之前,由系统默认调用.只执行一次

* 细节注意:

* 被static修饰的内容(静态的)会随着类的加载而加载,优先于对象.它的内容被所有对象所共享

* 静态的只能访问静态的,不能访问非静态的(类是静态的,对象是非静态的,因为有了类不一定有对象,但是有了对象就一定有类)

* 非静态的既能访问静态的,还能访问非静态的

继承:

子类自动拥有父类的属性和方法,关键字extends,之类也可用有自己的属性和方法

写法:子类 extends 父类

java中只支持单继承,不支持多继承

this:当前类的对象

* this():访问本类的无参数构造方法,系统不会默认给出,需要是必须写出

* this(参数):访问本类的有参构造方法

* this访问构造方法的时候必须放在构造方法第一行

* this和super访问构造方法不能共存

子类实例化过程:子类实例化时先实例化父类,在实例化子类

*super:父类的对象

* super():访问的是父类无参构造方法,即使不写super(),系统也会默认调用

* super(参数):访问的是父类的有参构造方法,需要在写

* super访问构造方法的时候必须放在子类构造方法的第一行

封装:隐藏内部实现细节,对外提供公共的访问方式

* private:私有访问权限,只能在该类的内部访问

* default:默认访问权限,只能被本类和同一包的类访问;不同的包不能访问,导包也不行

* protected:受保护的访问权限,只能被本类和同一包的类访问;不同包的子类可以访问,不同包的其它类不能访问

* public:公共访问权限,可以访问所有的类

方法覆盖:

又称重写.子类将父类的方法进行改造

* 前提:具备继承或者实现的关系

* 规则:方法名相同

* 参数列表相同(个数,顺序,类型)

* 返回值类型相同

* 子类的访问权限必须大于或等于父类的访问权限

* 抽象:abstract

* 可以修饰方法:抽象方法

* 抽象方法只有方法声明没有具体实现(没有花括号,,没有方法体),具体的实现需要子类帮他完成

* 可以修饰类:抽象类

* 包含抽象方法

* 包含非抽象方法

* 特殊情况,全部是抽象方法.全部是非抽象方法(抽象类不能创建对象,如果有不允许类创建对象的情况，可以联想抽象类的定义)

* 总结:有抽象方法的类一定是抽象类,抽象类中不一定有抽象方法

* 抽象类不能创建对象,但是有构造方法,构造方法是用来给属性赋值的

* 注意:abstract不可以跟和以下共存: private:只能访问本类,抽象类需要子类

* static:被static修饰的方法不能创建对象

final:被final修饰的没有子类,抽象类需要子类

* final:最终关键字

* 被它修饰的类不能被继承

* 被它修饰的方法不能被重写

* 被它修饰的量是一个常量不能被赋值

接口:关键字interface 实现接口:子类 implements 接口

* 接口不能创建对象,而且没有构造方法

* 常量:

* 固定修饰符号public static final默认会写

* 抽象方法:

* 固定修饰符号public abstract默认会写

* 默认方法:default 返回值类型方法名()

单例模式:

保证一个类只有一个实例(对象),并且提供公共地访问方式

public class Singleton {

//在自己内部定义自己的一个实例，只供内部调用

private static Singleton instance = new Singleton();

private Singleton(){

//do something

}

//这里提供了一个供外部访问本class的静态方法，可以直接访问

public static Singleton getInstance(){

return instance;

}

关系

* 类和类:单继承

* 类和接口:多实现

* 接口和接口:多继承

* 接口和抽象类的区别

* 1.一个类能实现多个接口,但是只能继承一个类

* 2.抽象类的方法可以用abstract和public和protected修饰;而接口的抽象方法默认为public abstract修饰

* 3.抽象类的方法可以是抽象方法也可以是普通方法,有构造方法;接口的方法有抽象方法和默认方法,没有构造方法

* 4.抽象类的属性可以用不同修饰符修饰;接口的属性用public static final来修饰,它是常量

* 5.抽象类可以继承抽象类,也能实现接口,接口只能继承接口

多态:不同的对象对同一行为做出不同的响应

* 多态的三个必要条件:

* 1.必须要有继承和实现的关系

* 2.必须方法重写

* 3.父类引用指向子类对象

引用数据转换:

* 上溯造型(向上转型):子类转化为父类小-->大

* 下塑造型(向下转型):父类转化成子类大-->小有强制的动作:(目标类型)变量

没有经过上溯造型的,不可以直接下塑造行

异常:凡是JVM中非正常的状况,我们都称为异常

* Throwable异常:

* Error:错误,灾难性问题,解决不了

* Exception:异常

* RuntimeException:非检查性异常(运行之后出现异常,可解决可不解决)

* IOException:检查性异常(解决)

* 所谓非检查性异常和检查异常指的是:编译器是否检查

* 异常处理的两种方式:

* 自行处理:try(可能出现异常) catch(捕获并且处理异常),下面代码正常运行,不写的话有异常的话代码就不运行了

* 回避异常:throws

* throws和throw的区别

* 定义的位置:

* throws:定义在方法体上

* throw:定义在方法体内

* 含义:

* throws:抛出异常,表示该方法中有异常

* throw:抛出异常,表示该方法中产生了一个异常

* 常见的五个异常:

* 1.算法错误异常

* 2.数组越界异常

* 3.空指针异常

* 4.类型转换异常

* 5.数据库操作异常

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

Object类是所有类的超类,唯一一个没有父类的类

* ==和equals的区别 (面试题)

* ==既可以比较基本数据类型也可以比较引用数据类型,基本数据类型比较的是值,引用数据类型比较的是地址值

* equals只能比较引用数据类型,重写之前比较的的是地址,重写后比较内容

字符串区别面试题

* String:内容不可变的字符串

* StringBuffer和StringBulider:内容可变的字符串

* StringBuffer和StringBulider的区别

* StringBuffer类是线程安全的；

StringBuilder类是线程不安全的。

StringBuffer在JDK1.0中就有，而StringBuilder是在JDK5.0后才出现的。

StringBuilder的一些方法实现要比StringBuffer快些。

* 静态方式创建字符串和动态方式创建字符串的区别

* 静态:使用静态方式创建的字符串，在方法区的常量池中只会产生唯一一个字符串对象，使用该方式产生同样一个字符串时，

* 内存中不再开辟另外一块空间，而是两个引用变量指向同一个字符串对象。

动态:使用动态方式创建的字符串，在堆内存中会产生出不同的对象。

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

数组和集合的区别:

* 数组:可以存放基本数据类型,也可以存放引用数据类型,长度是固定的,访问数度过快,但是不会自动扩充

* 集合:只能存放引用数据类型,可以扩充,常用

*Collection集合:

* Set:存放的内容是无序不重复的

* 无序:存数据时候的顺序和存进去之后的顺序不一致

* List:存放的内容是有序可重复的

List:有序可重复的接口

* ArrayList与LinkedList的比较

存储结构

ArrayList是线性顺序存储

LinkedList对象间彼此串连起来的一个链表

操作性能

ArrayList适合随机查询的场合

LinkedList元素的插入和删除操作性高

从功能上

LinkedList要多一些

父类/父接口不可以使用子类特有的方法,兄弟关系也不能共用特定的方法

Map:双列集合,键值对方式存储,键不可以重复,值可以重复

HashMap类

* HashMap与TreeMap的比较

HashMap基于哈希表实现。

TreeMap基于树实现。

HashMap可以通过调优初始容量和负载因子，优化HashMap空间的使用。

TreeMap没有调优选项，因为该树总处于平衡状态

HashMap性能优于TreeMap

HashMap与Hashtable的比较

Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现。

Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的。

HashMap允许将null作为一个entry的key或者value，而Hashtable不允许用null。

泛型经常被称为参数化类型,使用<>形式处理

Spring框架知识点

1. Spring是什么

轻量级控制反转(IOC)和面向切面(AOP)的容器框架

2. bean创建的两种规则

(1). beanFactoyr:

提供一种延迟加载思想来创建bean对象,bean对象什么时候用什么时候创建

(2).ApplicationContext:

提供的是一种立即加载来创建bean对象,只要解析完配置文件,就立刻创建bean对象

3.bean三种实例化方式

(1).使用默认无参构造创建(开发中常用)

默认情况下,如果类中没有默认无参构造方法,则创建失败,会报异常

(2).使用静态工厂形式创建

需要使用bean标签的factory-method属性,指定静态工厂中创建对象的方法

(3).使用实例工厂形式创建

因为实例工厂的方法不是静态的,所以需要先创建工厂对象,在通过工厂实例创建Service对象

4.bean的作用范围

它是可以通过配置属性的方式调整作用范围

配置的属性:bean标签的scope属性

属性的取值:

singleton:单例的(默认值)

prototype:多例的(struts2中常用)

request:作用范围一次请求,和当前请求的转发

session:作用范围是一次对话

globalsession:作用范围是一次全局会话

5.bean的生命周期

设计两个属性:init-method destroy-method

单例:

出生:容器创建,对象出生了

活着:容器在,对象一直在

死亡:容器销毁,对象销毁(调用close方法)

多例:

出生:每次使用对象的时候创建对象

活着:只要对象在使用中,就一直活着

死亡:当对象长时间不使用,并且也没有别的对象引用时,由java的垃圾回收机制回收

6.依赖注入

配置资源通过-构造方法注入

涉及到的标签:<constructor-arg>

标签的属性:

下三个指定哪个参数要赋值

type:指定参数的类型

index:指定参数的索引位置,从0开始

name:指定参数的名称,常用

下两个指定赋什么值

value:指定基本数据类型或者String类型的数据

ref:指定其他bean类型的数据

配置资源-通过set方法注入:

比较常用,因为不涉及到有参数和无参数构造方法的问题,以及修改参数个数的问题,提供getset就行

涉及的标签:property