java基础知识总结

java基础知识总结

JDK：java的开发和运行环境，Java的开发工具和jre

JRE：Java程序的运行环境，java运行的所需的类库+JVM（java虚拟机）

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

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

2、java：负责运行部分，会启动JVM加载运行时所需的类库，并对class文件进行执行。

 

java语法基础

1，关键字：其实就是某种语言赋予了特殊含义的单词。 保留字：其实就是还没有赋予特殊含义，但是准备日后要使用过的单词。

2，标示符：其实就是在程序中自定义的名词。比如类名，变量名，函数名。包含 0-9、a-z、$、_ ； 注意：    1），数字不可以开头。    2），不可以使用关键字。

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

4，变量：其实就是内存中的一个存储空间，用于存储常量数据。    作用：方便于运算。因为有些数据不确定。所以确定该数据的名词和存储空间。    特点：变量空间可以重复使用。

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

变量空间的开辟需要什么要素呢？   1，这个空间要存储什么数据？数据类型。   2，这个空间叫什么名字啊？变量名称。   3，这个空间的第一次的数据是什么？ 变量的初始化值。

变量的作用域和生存期:

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

生命周期：   变量从定义的位置开始就在内存中活了；   变量到达它所在的作用域的时候就在内存中消失了；

数据类型： 1）：基本数据类型：byte、short、int、long、float、double、char、boolean 2）：引用数据类型: 数组、类、接口。

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

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

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

运算符号： 1）、算术运算符。

• • • / % %:任何整数模2不是0就是1，所以只要改变被模数就可以实现开关运算。 +:连接符。    ++,–

2）、赋值运算符。    = += -= *= /= %=

3）、比较运算符。   特点：该运算符的特点是：运算完的结果，要么是true，要么是false。

4）、逻辑运算符。

  & | ^ ! && ||

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

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

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

   ^:异或：和或有点不一样。     两边结果一样，就为false。     两边结果不一样，就为true.   & 和 &&区别： & ：无论左边结果是什么，右边都参与运算。        &&：短路与，如果左边为false，那么右边不参数与运算。   | 和|| 区别：|：两边都运算。        ||：短路或，如果左边为true，那么右边不参与运算。 5）、位运算符:用于操作二进制位的运算符。   & | ^   & << >> >>>(无符号右移)

构造函数和一般函数有什么区别呢？

1：两个函数定义格式不同。

2：构造函数是在对象创建时，就被调用，用于初始化，而且初始化动作只执行一次。

一般函数，是对象创建后，需要调用才执行，可以被调用多次。

String及包装类：

1、String类型是final类型，在堆中分配空间后内存地址不可变。

2、 底层是final修饰的char[]数组，数组的内存地址同样不可变。

但实际上可以通过修改char[n] = 'a'来进行修改，不会改变String实例的内存值，不过在jdk中，用户无法直接获取char[]，也没有方法能操作该数组。

所以String类型的不可变实际上也是理论上的不可变。所以我们在分配String对象以后，如果将其 = "abc"，那也只是改变了引用的指向，实际上没有改变原来的对象。

3、StringBuffer和StringBuilder底层是可变的char[]数组，继承父类AbstractStringBuilder的各种成员和方法，实际上的操作都是由父类方法来完成的

final关键字

1、final修饰基本数据类型保证不可变

2、final修饰引用保证引用不能指向别的对象，否则会报错。

3、final修饰类，类的实例分配空间后地址不可变，子类不能重写所有父类方法。因此在cglib动态代理中，不能为一个类的final修饰的函数做代理，因为cglib要将被代理的类设置为父类，然后再生成字节码。

final修饰方法，子类不能重写该方法。

抽象类和接口

1、 抽象类可以有方法实现。 抽象类可以有非final成员变量。 抽象方法要用abstract修饰。 抽象类可以有构造方法，但是只能由子类进行实例化。

2、 接口可以用extends加多个接口实现多继承。 接口只能有public final类型的成员变量。 接口只能有抽象方法，不能有方法体、 接口不能实例化，但是可以作为引用类型。

代码块和加载顺序

假设该类是第一次进行实例化。那么有如下加载顺序 静态总是比非静态优先，从早到晚的顺序是： 1. 静态代码块 和 静态成员变量的顺序根据代码位置前后来决定。 2. 代码块和成员变量的顺序也根据代码位置来决定 3. 最后才调用构造方法构造方法

异常

1、 异常体系的最上层是Throwable类 子类有Error和Exception Exception的子类又有RuntimeException和其他具体的可检查异常。

2、Error是jvm完全无法处理的系统错误，只能终止运行。

运行时异常指的是编译正确但运行错误的异常，如数组越界异常，一般是人为失误导致的，这种异常不用try catch，而是需要程序员自己检查。

可检查异常一般是jvm处理不了的一些异常，但是又经常会发生，比如Ioexception，Sqlexception等，是外部实现带来的异常。

3、 多线程的异常流程是独立的，互不影响。 大型模块的子模块异常一般需要重新封装成外部异常再次抛出，否则只能看到最外层异常信息，难以进行调试。

日志框架是异常报告的最好帮手，log4j，slf4j中，在工作中必不可少。

枚举类

1、 枚举类继承Enum并且每个枚举类的实例都是唯一的。

2、 枚举类可以用于封装一组常量，取值从这组常量中取，比如一周的七天，一年的十二个月。

3、枚举类的底层实现其实是语法糖，每个实例可以被转化成内部类。并且使用静态代码块进行初始化，同时保证内部成员变量不可变

序列化

1、 序列化的类要实现serializable接口

transient修饰符可以保证某个成员变量不被序列化

readObject和writeOject来实现实例的写入和读取。

2、 事实上，一些拥有数组变量的类都会把数组设为transient修饰，这样的话不会对整个数组进行序列化，而是利用专门的方法将有数据的数组范围进行序列化，以便节省空间。

java 面向对象三大特性（封装，继承，多态）以及抽象、接口

封装：

1.定义：隐藏对象的属性和实现细节，仅对外公开接口,控制在程序中属性的读和修改的访问级别。

2.封装的目的是：增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，一特定的访问权限来使用类的成员。

3.封装的基本要求是:把所有的属性私有化，对每个属性提供getter和setter方法，如果有一个带参的构造函数的话，那一定要写一个不带参的构造函数。在开发的时候经常要对已经编写的类进行测试，所以在有的时候还有重写toString方法，但这不是必须的。

继承：

1.目的：实现代码的复用。

2.介绍：当两个类具有相同的特征（属性）和行为（方法）时，可以将相同的部分抽取出来放到一个类中作为父类，其它两个类继承这个父类。继承后子类自动拥有了父类的属性和方法，但特别注意的是，父类的私有属性和构造方法并不能被继承。另外子类可以写自己特有的属性和方法，目的是实现功能的扩展，子类也可以复写父类的方法即方法的重写。子类不能继承父类中访问权限为private的成员变量和方法。子类可以重写父类的方法，及命名与父类同名的成员变量。有时候我们需要这样的需求：我们需要将某些事物尽可能地对这个世界隐藏，但是仍然允许子类的成员来访问它们。这个时候就需要使用到protected。

多态：

1.概念：相同的事物，调用其相同的方法，参数也相同时，但表现的行为却不同。

1. Java实现多态有三个必要条件：继承、重写、向上转型。

继承：在多态中必须存在有继承关系的子类和父类。

重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。

向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。

只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。

3.多态的实现方式：

（1）基于继承实现的多态

基于继承的实现机制主要表现在父类和继承该父类的一个或多个子类对某些方法的重写，多个子类对同一方法的重写可以表现出不同的行为。

（2）基于接口实现的多态

继承是通过重写父类的同一方法的几个不同子类来体现的，那么就可就是通过实现接口并覆盖接口中同一方法的几不同的类体现的。

在接口的多态中，指向接口的引用必须是指定这实现了该接口的一个类的实例程序，在运行时，根据对象引用的实际类型来执行对应的方法。

继承都是单继承，只能为一组相关的类提供一致的服务接口。但是接口可以是多继承多实现，它能够利用一组相关或者不相关的接口进行组合与扩充，能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。

 

4.多态性主要表现在如下两个方面:

(1)方法重载.通常指在同一个类中,相同的方法名对应着不同的方法实现,但是方法的参数不同.

 

(2)成员覆盖.通常指在不同类(父类和子类)中,允许有相同的变量名,但是数据类型不同;也允许有相同的方法名，但是对应的方法实现不同.

 

5.多态的好处：程序的可扩展性及可维护性增强。

抽象：

1.介绍：在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、 设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象，我们不能把它们实例化（拿不出一个具体的东西）所以称之为抽象。

　　比如：我们要描述“水果”，它就是一个抽象，它有质量、体积等一些共性（水果有质量），但又缺乏特性（苹果、橘子都是水果，它们有自己的特性），我们拿不出唯一一种能代表水果的东西（因为苹果、橘子都不能代表水果），可用抽象类来描述它，所以抽象类是不能够实例化的。当我们用某个类来具体描述“苹果”时，这个类就可以继承描述“水果”的抽象类，我们都知道“苹果”是一种“水果”。

2.抽象方法：被abstract修饰的方法是抽象方法，抽象方法没有方法体。修饰符 abstract 返回值类型 函数名();抽象方法的修饰符只能用public或者protected或者没有修饰，不能被final，static，private修饰。

（1）、类即使不包含抽象方法，也可以定义成抽象类。 （2）、类中含有抽象方法的类一定要定义成抽象类。 （3）、抽象类中字段的定义和子类的访问与一般类没有变化。 （4）、扩展抽象类有两种方法，第一种是在子类中定义部分抽象方法或者抽象方法不定义，这样子类也必须定义成抽象类，第二种是定义全部的抽象方法，这样子类就可以不定义成抽象的了。 （5）、抽象类不能被实例化，但是可以定义一个抽象类的对象变量，这个变量可以引用非抽象子类的对象。 （6）、抽象类中包含有构造方法，也可以显式书写构造方法，构造方法在实例化子类的对象中调用。

接口与抽象类的区别:

不同点： 1、接口可以多实现，而抽象类只能单继承 2、抽象类可以有非抽象的方法和构造方法、变量，但是接口只能有抽象方法，静态常量。 3、抽象类和子类具有父子关系，子类能拥有父类中一些属性。接口虽然某个类实现一个接口，但是由于接口中的变量都为静态常量，不存在继承关系。

相同点： 1、无论接口还是抽象类，都无法直接实例化，其自身实例化需要靠实现类或子类来实现。 2、接口和抽象类都必须实现其中的所有方法。

抽象类（abstract class）的定义方式如下：

public abstract class AbstractClass //里面至少有一个抽象方法
{
　　public int t; //普通数据成员
　　public abstract void method1(); //抽象方法，抽象类的子类在类中必须实现抽象类中的抽象方法
　　public abstract void method2();
　　public void method3(); //非抽象方法
　　public int method4();
　　publi int method4 (){
　　……//抽象类中可以赋予非抽象方法方法的默认行为，即方法的具体实现
　　}
​
public void method3(){
　　……//抽象类中可以赋予非抽象方法方法的默认行为，即方法的具体实现
　　}
​
}
​
 
​
接口（interface）的定义方式如下：
​
​
public interface Interface
{
　　static final int i; //接口中不能有普通数据成员，只能够有静态的不能被修改的数据成员,static表示全局，final表示不可修改，可以不用static final修饰，会隐式的声明为static和final
　　
​
　　 public void method1(); //接口中的方法一定是抽象方法，所以不用abstract修饰
　　
​
　　public void method2();//接口中不能赋予方法的默认行为，即不能有方法的具体实现
}

 

1、一个接口可以被多个类实现，一个类也可以实现多个接口。 2、接口中所有的定义的字段默认都是public static final 的属性，写和不写没有区别。 3、接口中的方法都是抽象的方法，并且抽象的方法默认都是public abstract修饰的，不能用其他的修饰符修饰，可以不写。 4、接口中没有构造方法 5、接口不是类，尤其不能使用new运算符实例化一个接口。但是可以声明接口的变量，这个变量可以指向实现了此接口的子类。

简言之抽象类是一种功能不全的类，接口只是一个抽象方法声明和静态不能被修改的数据的集合，两者都不能被实例化。

　从某种意义上说，接口是一种特殊形式的抽象类，在ｊａｖａ语言中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。在许多情况下，接口确实可以代替抽象类，如果你不需要刻意表达属性上的继承的话。

super的用法：

1.子类的构造函数如果要引用super的话，必须把super放在函数的首位.

classBase {
​
Base() {
​
System.out.println("Base");
​
}
​
}
​
 
​
publicclassChecketextendsBase {
​
Checket() {
​
super();//调用父类的构造方法，一定要放在方法的首个语句
​
System.out.println("Checket");
​
}
​
 
​
publicstaticvoidmain(String argv[]) {
​
Checketc=newChecket();
​
}
​
}

如果想用super继承父类构造的方法，但是没有放在第一行的话，那么在super之前的语句，肯定是为了满足自己想要完成某些行为的语句，但是又用了super继承父类的构造方法。那么以前所做的修改就都回到以前了，就是说又成了父类的构造方法了。

 

2．在java中，有时还会遇到子类中的成员变量或方法与超类（有时也称父类）中的成员变量或方法同名。因为子类中的成员变量或方法名优先级高，所以子类中的同名成员变量或方法就隐藏了超类的成员变量或方法，但是我们如果想要使用超类中的这个成员变量或方法，就需要用到super.

classCountry {
​
Stringname;
​
 
​
voidvalue() {
​
name="China";
​
}
​
}
​
 
​
classCityextendsCountry {
​
Stringname;
​
 
​
voidvalue() {
​
name="Hefei";
​
super.value();//不调用此方法时，super.name返回的是父类的成员变量的值null
​
System.out.println(name);
​
System.out.println(super.name);
​
}
​
 
​
publicstaticvoidmain(String[] args) {
​
City c=newCity();
​
c.value();
​
}
​
}

为了在子类中引用父类中的成员变量name和方法value()，在代码中使用了super、super.name和super.value(),若不调用super.value()时，super.name返回父类成员变量默认值null,调用此方法时，super.value()方法把成员变量name赋值为China,再利用super.name调用父类的成员变量的值。

另外，要注意的是super.name调用的是成员变量的值，

classCountry {
​
Stringname="xianfan";
​
 
​
String value(String name) {
​
name ="China";
​
returnname;
​
}
​
}
​
 
​
classCityextendsCountry {
​
Stringname;
​
 
​
String value(String name) {
​
name ="Hefei";
​
super.value("失败");//不调用此方法时，super.name返回的是父类的成员变量的值null
​
System.out.println(name);
​
System.out.println(super.name);
​
returnname;
​
}
​
 
​
publicstaticvoidmain(String[] args) {
​
City c=newCity();
​
c.value("成功");
​
}
​
}
​
结果为：Hefei
​
xianfan
​
此时，super.name返回的值是父类成员变量的值xianfan,而此时的super.value()方法是不起作用的。

3．用super直接传递参数：

classPerson {
​
publicstaticvoidprt(String s) {
​
System.out.println(s);
​
}
​
 
​
Person() {
​
prt("A Person.");
​
}
​
 
​
Person(String name) {
​
prt("A person name is:"+ name);
​
}
​
}
​
 
​
publicclassChineseextendsPerson {
​
Chinese() {
​
super();//调用父类构造函数（1）
​
prt("A chinese.");// (4)
​
}
​
 
​
Chinese(String name) {
​
super(name);//调用父类具有相同形参的构造函数（2）
​
prt("his name is:"+ name);
​
}
​
 
​
Chinese(String name,intage) {
​
this(name);//调用当前具有相同形参的构造函数（3）
​
prt("his age is:"+ age);
​
}
​
 
​
publicstaticvoidmain(String[] args) {
​
Chinesecn=newChinese();
​
cn =newChinese("kevin");
​
cn =newChinese("kevin", 22);
​
}
​
}
​
结果为：A Person.
​
A chinese.
​
A person name is:kevin
​
his name is:kevin
​
A person name is:kevin
​
his name is:kevin
​
his age is:22
​
在这段程序中，this和super不再是像以前那样用“.”连接一个方法或成员，而是直接在其后跟上适当的参数，因此它的意义也就有了变化。super后加参数的是用来调用父类中具有相同形式的构造函数，如1和2处。this后加参数则调用的是当前具有相同参数的构造函数，如3处。当然，在Chinese的各个重载构造函数中，this和super在一般方法中的各种用法也仍可使用，比如4处，你可以将它替换为“this.prt”(因为它继承了父类中的那个方法）或者是“super.prt”（因为它是父类中的方法且可被子类访问），它照样可以正确运行。但这样似乎就有点画蛇添足的味道了。

super和this的异同：

1)super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）

2)this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句） 3)super:　它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名super.成员函数据名（实参）

4)this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）

 

5）调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。

6）super()和this()类似,区别是，super()从子类中调用父类的构造方法，this()在同一类内调用其它方法。

　 7）super()和this()均需放在构造方法内第一行。

　 8）尽管可以用this调用一个构造器，但却不能调用两个。

　 9）this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。

　10）this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。

　11）从本质上讲，this是一个指向本对象的指针,然而super是一个Java关键字。