JAVA基础知识点总结

快捷键
代码编写规则
多态
抽像类和接口：
问题汇总
数据类型
类
包
向上转型：
final修饰符
内部类
接口
面向接口编程的好处：
异常处理
捕捉处理异常
抛出异常
自定义异常
常用实用类

快捷键

<ctrl +alt+/> 自动补全
<alt+/> 代码辅助
<alt+shift+/> 添加注释
<ctrl+1>代码修复
面向对象更加符合人的思维模式，编写的程序更加健壮和强大，更重要的是面向对象程序设计的特点主要有封装性、继承性、和多态性。

代码编写规则

类名：
每个单词首字母大写，其它字母小写，如RecordInfo
变量名和方法名：
除第一个单词首字母小写外，其它单词的首子母大写，如getReordName(),recordName.
常量名：
每个单词的字母都大写，如果有多个单词组成，那么在通常情况下单词之间用下划_线分隔。
包名：
每个单词的每个字母都要小写
说明：
在为float型常量赋值时，需要在数值的后面加一个字母“F”或“f”,说明数值为float型。

多态

多态：
1.重载：指一个类中出现多个方法名称相同，参数个数或类型不同。作用：根据参数个数和类型决定执行的是哪个方法。
2.重写：子类中方法名与父类相同，作用：一个方法在不同子类表现不同的行为。
注意：1.子类不能覆盖父类中声明为final或static的方法。
2.子类必须覆盖父类中声明为abstract的方法，或者子类也将该方法声明为abstract.
3.当子类覆盖父类中的同名方法时，子类中方法的声明也必须和父类中被覆盖的方法的声明一样。

抽像类和接口：

抽像类作为模板，是从多个具体类中抽像出来的父类，它具有更高层次的抽像，从多个具有相同特征的类中抽像一个抽像类，以这个抽像类为模板，从而避免子类的随意设计，子类在抽像类的基出上进行扩展，但是子类大致保留抽象类的行为。
面向接口编程的好处：面向接口是编程是使用接口来约束类的行为，并为类和类之间的通信建立实施标准。使用面向接口编程增加了程序的可维护性和可扩展性。可维护性提现在：当修改子类的功能时，只要接口不发生改变，系统其他代码就不需要改动。可扩展性体现在：当增加一个子类时，测试类和其它代码都不需要改动。如果子类增加了其它功能，则只需要子类实现其它接口即可。使用接口可以实现程序设计的“开-闭原则”，即对扩展开放，对修改关闭。
接口与抽像类的用法差别如下：

子类只能继承一个抽像类（一个亲爸（类）），但可以实现任意多个接口（多个干爸）
一个子类要实现一个接口必须实现接口中的所有方法，而抽像类不必。
抽像类中的成员变量可以是各种类型的，而接口中变量只能是public,static,final的。
接口中只能定义抽像方法，而抽像类中可以定义非抽像方法，这就是为什么接口中的方法前面不用再加abstract关键词。
抽像类中可以有静态方法和静态代码块，但接口中不可以，不然实现类怎么去实现呀。
接口不可以被实例化，没有构造方法，但抽象类可以有构造方法。
公共类的名称必须与类文件同名，内部类不能用public，一般内部类修饰符不写。

问题汇总

1.什么是JSP内置对像？常用JSP内置对象有哪些？作用分别是什么？P169
答：由于JSP使用Java作为脚本语言，所以JSP具有强大的对象处理能力，并且可以动态创建WEB页面内容，但java语言在使用一个对象前，需要先实力化这个对象，这其实是一件比较繁琐的事情，JSP为了简化开发，提供了一些内置对像，用来实现很多JSP应用，在使用JSP内置对象时，不需要先定义这些对象，直接使用即可。在JSP中共预先定义了9个这样的对象，分别为request(由客户端生成的HTTP请求的所有细节，处理客户端浏览器提交的HTTP请求中的各项参数),reponse(响应客户请求，向客户端输出信息),session（可以存储与读取客户相关的信息，通过session可以当用户在应用程序的WEB页面跳转时，保存用户的状态，使整个会话一直存在下去，到浏览器关闭），application(保存全局变量),out(在web浏览器内输出信息),pageContext(几乎不用),config(读取WEB.XML配置信息),page(代表jsp本身，在本质上是包含当前servlet接口引用的变量),exception(获取异常信息).
2.什么是接口？和抽象类的区别？接口变量和抽象类变量的作用？什么是接口回调？
答：抽像类变量：用来存放实现类对象的引用。接口变量：可以存放实现该接口的类的实例对象引用，即存放象的引用。接口回调：指的是把实现某一接口的类所创建的对象的引用赋值给该接口声明的接口变量。那么该接口变量就可以调用被类实现的接口方法。
3super关键字作用？
答：两个地方会用：1就是调用父类的构造方法。如果想在子类Bird的构造方法中通过如下代码进行调用。
public Animal(){｝
public Animal (String strSkin){
skin = strSkin;
}
public Bird(){
super(“羽毛”);
}2是操作被子类隐蔽的成员变量、成员方法的父类的成员变量和成员方法。
super.成员变量名，super.成员方法名（参数列表）；
即：
super代表用父类中被子类中隐藏的成员变量或成员方法。
this代表用类的成员变量，成员方法区分局部变量，局部方法。即this代表本类对象的引用。所以可以调用成员变量和成员方法，也可以作为方不的返回值。
**4.Spring AOP的3种织入方式是？AOP的切入点类型3种：静态、动态、自定义各用在什么场合？**P288
答：
5.抽象方法不能被private或static修饰，正确。
6.开发项目怎么达到项目代码的高内聚，低耦合？
答：如果不使用框架，而单纯使用servlet和jdbc，甚至只用jsp技术，同样可实现javaweb的项目开发，但这样的项目量大，代码之间的耦合度极强，如果需要调整某一功能，出于连锁反应，可能要修改所有的源代码文件，这样的项目维护起来存在极大的风险隐患。使用框架可以省去很多的烦琐，重复的代码操作，大大降低了代码之间的耦合性。
7.final类不能被继承，即不能有子类。final方法不能被重写，这样是为了程序的安全性。
8.通过代码片段和声明标识创建的变量或方法有什么区别？
答：通过声明标识创建的变量和方法在当前JSP页面中有效，它的生命周期是从创建开始到服务器关闭结束，而通过代码片段创建的变量或方法也在当前JSP页面中有效，但它在页面关闭后就会被销毁。即声明标只的生命周期要长一些，
说明：
JSP表达式：即可以插入网页的文本中，用于输出文本内容，也可以插入HTML标签中，用于动态设置属性值，<%= %>
声明标识：<%! %>，通常使用该标识定义整个JSP页面都需要引用的变量或方法。服务器在执行JSP页面时，会将JSP页面转换为Servlet类，在该类中会把使用声明标识定义的变量和方法转换为类的成员变量和成员方法。所以服务器关闭这些量才结束。
代码片段：<% %>,在JSP页面中嵌入的JAVA代码，代码片段奖在页面请求的处理期间被执行，通过JAVA代码可定义变量或流程控制语句，可以应用JSP的内置对象在页面输出内容，处理请求和响应，访问session会话等。
10.包含文件的动作标识和指令标识的区别？
答：<jsp:include page="url "
<%@ include file=“path”

数据类型

优先级从高到低：一元算数移位比逻辑。
基本数据类型:数值类型：1.整数类型（byte,short,int,long）2.浮点类型（float,duble）3.字符类型（char）4.布尔型
引用数据类型：1.类引用 2.接口引用 3.数组引用

在为long型常量或变量赋值时，需要在所赋值的的面加上一个字母"l"或“L”，说明所赋值的值为long型，如果所赋的值未超出int型的取值范围，则也可以省略字母“l”或“L”。
在为float型常量或变量赋值时，需要在所赋值的的面加上一个字母"f"或“F”，说明所赋值的值为float型，如果所赋的值为整数，并且未超出int型的取值范围，则也可以省略字母“f”或“F”。所赋的值为小数必须加上F
在为double型常量或变量赋值时，需要在所赋值的的面加上一个字母"d"或“D”，说明所赋值的值为double型，如果所赋的值为小数或者所赋的值未超出int型的取值范围，则也可以省略字母"d"或“D”。
可以将数据类型相对较低的数据或变量直接赋值给数据类型相对较高的变量，会自动转换，但是如果需要把数据类型相对较高的数据或变量赋值给数据类型相对较低低的变量，就必须进行强制类型转换。int i = (int)7.5,这种情况要注间数据的溢出，如本变量i的值就成了7.
说明：当将引用数据类型的常量或变量初始化为null时，表示引用数据类型的常量或变量不引用任何对象。
在具体初始化引用数据类型时需要注意的是，对接口引用的初始化需要通过接口的相应实现类实现。如List list = new ArrayList(); 对于引用数据类型的变量，java虚拟机同样要为其分配内存空间，但在内存空间中存放的并不是变量所引用的对象，而是对象在堆区存放的地址，所以引用变量最终只是指向被引用的对象，而不是存偖了被引用的对象。
int a = 5 & -4; 说明此处的&是逻辑位运算符，而逻辑与运算符是对boolean型数据进行运算的。
判断对象是否为某一类型，运算结果为boolean型。boolean i = instanceof(java.utl.Date);
switch多分支语句中表达式的值必须是整数或字符型。

类

类变量与实例变量的区别在于：在运行时Java虚拟机只为类变量分配一次内存，在加载类的过程中完成类变量的内存分配，可以直接通过类名访问类变量，而实例变量则不同，每创建一个实例，就会为该实例的变量分配一次内存。不能使用public、protected、private、static关键字对局部变量进行修饰，但可以使用final关键字。
类体中由成员变量和成员方法组成的，而对成员变量的操作只能放在方法中，方法使用各种语句对成员变量和方法体中声明的局部变量进行操作，在声明成员变量时可以赋初值。
public class A{
int a = 12; //在声明变量的同是赋予初始值是可以的
}
public class A {
int a ;
a = 12 ;//这样是非法的，对成员变量的操作只能出现在方法体中。

}
构造方法没有返回值，也不需要使用关键字void进行标识。如果类已经定义了一个或多个构造方法，那么java中不提供默认的构造方法；
在编写类时候：
类中的实例方法总是可以操作该类中的实例变量和类变量，
类方法总是可以操作该类中的类变量，不可以直接操作实例变量，因为在创建对象之前，实例变量还没有分配内存。

声明Apple类的一个对象redApple的代码Apple redApple;即在内存中为其建立了一个引用，并置初值为null，表示不指向任何内存空间，

包

java语言要求文件名和类名相同，所以如果将多个类放在一起，则很可能出现文件名冲突的情况，那就要使用包将类是行分组。即包是java语言提供的一种区别类的命名空间机制，是类的组织方式，是一组相关类和接口的集合。它提供了访问权限和命名的管理机制，主要有3种用途：
1、将功能相近的类放在同一个包中，可以方便查找与使用。
2，由于在不同包中可以存在同名类，所以使用包在一定程度上可以避免命名冲突。
3.在java语言中，某些访问权限是以包为单位的。友好变量和方法（无public、private、protected修饰）、友好类（没有用public修饰）不同包是不能用的，即不能出包。受保护的变量和方法在同一个包或不同包都可以使用。既然public和protected变量和方法在不同包都可以使用，区别是：protected只有他自身或继承它的类可以用。public是公有的，在静态下所有的类都可以通过类名打点调用。不是静态下可以用对象打点调用。
如果一个类中的某个变量是私有变量，那么在另一个类中，不能通这类名来操作这个私有变量，如果一个类中的某个方法是私有方法，那么在另一个类中，不能通过类名来操作这个私有方法。即私有变量和方法不能出类，即使子类继承都继承不了。友好变量和方法不能出包。
类可访问其所在包中的所有类，要使用其它包中的public类的两种方法：1.完整类名法。2.import法（同一个包中就不用import导包了）。

创建包：可以通过在类或接口的源文件中使用package语句来实现，package语句的语法如下：package 包名。package语句位于类或接口源文件的第一行。

向上转型：

一个对象可以看本类类型，也可以看作它的超类类型，取得一个对象的引用，并将它看作超类的对象，称为向上转型。

抽像类和抽像方法
所谓抽像类：就是只声明方法的存在而不去具体的实现它的类，抽像类不能被实例化，也就是不能创建其对象，在定义抽像类时，要在关键字class前面加上关键abstract,抽象类的构造器不能用于创建实例，主要用于被子类调用，对属性的初始化。接口没有构造方法。包含一个或多个抽像方法的类必须声明为抽像类，这是因为抽像方法没有定义方法的实现部分，如果不声明为抽像类，那么这个类将可以生成对象，当用户调用抽像方法时，程序就不知道如何处理了。

final修饰符

使用关键字final修饰的类被称为final类，该类不能被继承，即不能有子类，有时为了程序的安全性，可以将一些重要的类声明为final类，如java语言提供的System类和String类都是final类。被final修饰的方法不可以被重写。

内部类

java语言允许在类中定义内部类，内部类就是在其它类内部定义的子类，有四种形式
1.成员内部类，2 局部内部类 3静态内部类 4 匿名类
1.成员内部类和成员变量一样，属于类的全局成员，但成员变量可以为公有属性publican，但内部类不可以使用public修饰符，因为共公类的名称必须与类文件同名。所以每个java类文件中只允许一个公共类。只有创建了成员内部类实例，才能使用成员内部类的变量和方法
public class Simple{
class Inner{

}}
Sample sample = new Sample();
sample.Inner inner = sample.new Inner();//创建了成员内部类实例
2.局部内部类
局部内部类和局部变量一样，都是在方法内定义的，其只在方法内部有效。局部内部类可以访问它的创建类中的所有成员变量和成员方法，包括私有方法。
3.静态内部类
和静态变量类似，都使用static关键字修饰，
public class Sample{
static class Apple{
}
}静态内部类可以在不创建Sample类的情况下直接使用。
即：S(大写)ample.Apple apple = new Sample.Apple();
4.匿名类
就是没有名称的内部类，它经常被应用于Swing程序设计中的事件监听处理。有如下特点：1.匿名类可以继承父类的方法，也可以重写父类的方法。2.匿名类可以访问外嵌类中的成员变量和成员方法，但在匿名类中不能声明静态变量和静态方法。因为就没有类名。3.在使用匿名类时，必须在某个类中直接使用匿名类创建对象。4.在使用匿名类创建对象时，要直接使用父类的构造方法。
public class Sample{
new Apple(){
public void introducion(){}
}
}
虽然成功创建了一个Apple匿名内部类，但其内部的方法谁也无法使用他，这是因为没有一个对该类的引用。
匿名类经常被用来创建接口的唯一实现类。或者创建某一个子类的唯一子类。

接口

注意：java接口文件的文件名必须与接口名相同。接口可以被类实现，也可以被其它接口继承，在类实现接口时，方法的名字，返回值类型，参数的个数及类型必须与接口中的完全一致，并且必须实现接口中的所有抽像方法。
语法格式：
[修饰符] class <类名> [extends 父类名] [implements 接口列表]
public class Circ implements Calculate ,GeometryShape{
}
接口指定了系统各模块之间遵循的标准，体现的是一种规范，因此，接口一旦被定义，不应该经常改变，一旦改变会对整个系统造成影响，对于接口的实现者而言，接口规定了实现者必须向外提供哪些服务，对于接口的调用者而言，接口规定了调用者可以调用哪些服务，当多个应用程序之间使用接口时，接口是多个应用程序之间的通信标准。而抽像类作为多个子类的父类，它体现的是一种模板式设计，这个抽像父类可以被当成中间产品，但不是最终产品，需要进一步完善。
接口与多态：由接口实现的多态就是指不同的类在实同一个接口时可能具有不同的表现形式，

面向接口编程的好处：

面向接口编程是对多态特性的一种体现，面向接口编程是使用接口来约束类的行为，并为类和类之间的通信建立实施标准，使用面向编程增加了程序的可维护性和可扩展性，可维护性体现在：当修改子类的功能时，只要接口不发生改变，系统其它代码就不需要改动，可扩展性体现在：当增加一个子类时，测试类和其它代码都不需要改动，如果子类增加了其他功能，则只需要子类实现其它接口即可。使用接口可以实现程序设计的“开-闭原则”，即对扩展开放，对修改关闭，

异常处理

java语言的异常处理机制最大的优势就是可以将异常情况在方法调用中进行传递，通过传递可以将异常情况传递到合适的位置再进行处理。使用这种异常处理机制，使得java语言的异常处理更加灵活，使用java语言编写的项目更加稳定，java是一门向对象的编程语言，因此异常在java语言中也是作为类的实例的形式出现的。当某一方法中发生错误时，这个方法会创建一个对象，并且把它传递给正在运行的系统，这个对象就是异常对象。通过异常处理机制可以将非正常情况下的处理代码与程序的主逻辑分离，即在编写代码主流程的同时在其它地方处理异常。
java类库的每个包中都定义了异常类，所有这些类都是Throwable类的子类，其派生了两个子类，分别是Error和Exception类，其中Error类及其子类用来描述java运行系统中的内部错误及资源耗尽的错误。这类错误比较严重,通常会停止运行，而且这类错误无法使用异常处理语局处理。Exception类被称为非致命性类，可以通过捕捉处理使程序继续执行。Exception类又可以根据错误发生的原因分为运行时异常（JAVA提供了常见的运行时异常，这些异常可通过try…catch语局捕获，如空指针，数组下标越界，算术异常、非法参数、文件系统未找到、安全性异常、字符串索引超出范围等）和非运行时异常（如果不处理，程序就不能编译通过），对于运行异常，必须使用try…catch代码块进行处理或者使用throws关键字抛出。

捕捉处理异常

try…catch代码块主要用来对异常进行捕捉并处理，在实际使用时，该代码块还有一个可选的finally代码块，其标准语法如下：
try{
//程序代码块，此代码块中发生异常后，try代码块出错语局后面的代码不再执行，而程序就会跳转到catch代码块中执行，执行完catch代码块中的程序代码后，将继续执行catch代码块后的其它代码，而不会执行try代码块中发生异常语局后面的代码。由此可知，java语言的异常处理是结构化的，不会因为一个异常而影响整个程序的执行。
}
catch(Exceptiontype e对象名){
//对Exceptiontype的处理
e.printStackTrace();//输出异常的栈日志
e.getMessage();//获取异常事件的信息
e.toString();//获取异常的类型与性质
注意：如果使用了多个catch代码块，则catch代码块中的异常类顺序是先子类后父类。因为父类的引用可以引用子类的对象。
}
finally{
//代码块，无论程序是否发生异常，此代码块都会被执行，因此在finlly代码块中通常放置一些释放资源、关闭对象的代码。以下三种情况finally代码块中的代码不会被执行，1，在finlly代码块中发生了异常。2，在前面的代码中使用了System.exit()退出程序，3.程序所在的线程死亡。
}

抛出异常

如果某个方法可能发生异常，但不想在当前方法中处理这个异常（使用try…chtch），则可以使用throws、throw关键字在方法中抛出异常，。
throws关键字通常被用在声明方法时，用来指定该方法可能抛出异常，多个异常可以使用逗号分隔，如果方法抛出出异常，那么在谁调用该方法时，必须为捕捉的方法处理异常，当然如果使用throws关键字将异常继续抛出给上一级不想处理该异常，则可以继续向上抛出出异常，但最终要有能够处理异常的代码。语法格式如下：
返回值类型方法名（参数列表） throws 异常类型名｛
方法体
｝
public calss Shoot{
static void pop() throws NegativeArraySizeException{
int[] arr = new int[-3];
}
public static void main (String[] args){
try{
pop(); //调用上面可能异常的方法，谁调用谁通过try…catch来捕获。如果此方法不想处理，可以在此方法上通过throws接着往上级抛
}catch(NegativeArraySizeException e){
system.out.printIn(“pop()就去抛出的异常”);
}
}

}
throw关键字通常用于在方法体中“制造”一个异常。既然是制造一个异常，这个异常一发生，程序执行到throw语局时立即终止，它后面的语局都不执行，throw关键字通常用在程序出现某种逻辑错误时，由开发者主动抛出某种特性类型的异常，以便使它的调用者知道要捕获这个异常，而throw是直接抛出一个异常实例,即通常用来抛出用户自定义的异常。语法格式如下：
throw new 异常类型名即自定义异常类型名（异常信息）
如：
public class ThrowTest{
public static void main(String[] args){
int num1=25;
int num2=0;
int result;
if(num2==0){
throw new ArithmeticException(“这都不会，小学生都知道，除数不能是0”);
}
result = num1/num2;
System.out.println(“两个数的商为：”+result);
}
}
说明：通过throw关键字抛出异常后，如果想在上一级代码中（即谁来调用）捕获并处理异常（即用try…catch）,那么最好在抛出异常的方法声明中使用throws关键字指明要抛出的异常，如果要捕捉throw抛出的异常，同样需要使用try…catch代码块。

自定义异常

自定义异常主要用在以下场合：
1，使异常信息更加具体，2.程序中有些错误是符合java语法的，但不符合业务逻辑或者实际情况，如程序中出现一个人的年龄是负数，人员个数是小数等。3.在分层的软件架构中，通常由表现层进行异常捕获和处理。
public calss MyException extends Execption{ //创建自定义异常，继承Exception类
public MyException(String ErrorMessage){ //构造方法
super(ErrorMessage);//调用父类的构造，并把自定义的异常消息内容传递给父类构造
}
}
下面通过throw使用上面自定义的异常类
public class Tran{
//定义方法，在方法体内通过throw制造异常，并把此含有异常的方法抛出去给上一级处理，即通过throws抛出给上一级。
static void avg(int age) throws MyException{
if (age<0){
throw new MyExecption(“年龄不可以是负数”)；
}else{
System.out.pringln(“王师傅的年龄是：”+age+“岁”);
}
}
public static void main(String[] args){
//调用上面可能有异常的方法进行捕获
try{
avg(-50);
}catch(MyException e){
e.printStackTrace();
}
}
}
说明：1.避免使用catch(Exception e),因为如果所有的异常都采用相同的处理方式，则将导致无法对不同异常分情况处理，另外这种情况捕获方式可能将程序中的全部错误，异常捕获到，2.不要忽略捕捉到的异常，遇到异常一定要及时处理。3.如果父类抛出多个异常，则重写该方法必须抛出相同的异常或其异常的子类。不能抛出新的异常。

常用实用类

字符串是java程序中经常处理的对象，以对象的方式处理字符串，将使字符串更加灵活，方便。java语言中不能定基本类型对像，为了能将基本类型视为对象进行处理，并能连接相关的方法，java语言为每个基本类型都提供了包装类，
String类
创建字符串对象时，可以通过双引号初始化字符串对象，也可以通过构造方法创建并初始化字符串对象，其语法格式如下：
String aStr = “sfja”;
String bStr = new String(“sdsf”);
String cStr = “”;
注意：一个空字符串并不是说它的值等于null(空值)，空字符串和null(空值)是两个概念。
连接字符串：对于“+”运算符，如果有一个操作元为String类型，则为字符串连接运算符。字符串可与任意类型的数据进行字符串连接操作。若该数据为基本数据类型则会自动转换为字符患，若为引用数据类型则会自动调用所引用对象的toSring()方法获得一个字符串，然后进行字符连接操作。连接运算符先左后右的结合顺序。
//与引用类型连接
System.out.pringln(“路径”+(new java.io.File(“c/;text.txt”))); 结果：路径：C：\text.txt
System.out.prongln(“10”+7.5F); 结果：107.5F
System.out.prongln(100+6.4+“MR”); 结果：106.4MR
System.out.prongln(“MR”+100+6.4); 结果：MR1006.4
StringBuffer类
String字符串不能修改、删除、或替换字符串中的某个字符，而StringBuffer类创建的字符串对象是可以修改的。String与StringBuffer属于不同的类型，不能直接强制类型转换。
Random类
Random rd = new Random();
//如果想获取一个指定范围的随即数
rd.nextInt(int m);//即0到m之间且包括0，但不包括m的一个随即数。
Integer类、Long类、Short类
分别将基本类型int,longg,short封装成一个类，Integer类中的toString()方法可以将Integer对象转换成十进制字符串，toBinaryString()转换成二进制字符串，toHexString()转换成十六进制字符串，toOctalString()转换成八进制字符串。
还有Booean类、Byte类、Character类、Double类、Number类（即BigDecimal,BigInteger,Byte,Double,Float,Integer,Long,Short类的父类）

Date类
Date date = new Date();
//设置日期格式
SimpleDateFormat df = new SimpleDateFormate(“yyyy-MM-dd HH:mm:ss”);
String today = df.format(date);//获取当前的系统日期。