Java基础总结


JVM：(Java Virtual Machine)即Java虚拟机；所谓Java虚拟机，就是可以运行Java代码的假想计算机。我们只需要根据Java虚拟机的规范，将其安装到某台特定的计算机上，就可以使编译过的Java代码达到“编写一次，到处运行”的目的。

JDK的安装，环境变量的配置

安装JDK时只要按照安装程序一直“下一步”即可，也可以选择性的安装J2SE Runtime Environment。

配置JDK（Java Development Kits）环境变量两种方法：

第一种：直接修改path路径；

第二种：在系统变量中新建JAVA-HOME环境变量；在环境变量路径值为：“%JAVA-HOME%\bin”;-

这两种方法其中第一种较为常用，第二种主要用于切换版本和TOMCAT的软件配置；

Classpath的作用

它的主要作用是寻找.class文件；

第一种：在系统变量中新建一个系统变量，命名为：classpath,并把变量值设为：.;D:\code;

第二种：在Dos环境下直接修改，但是只对当前窗口有效，很少用；

JAVA数据类型

首先java数据类型包括基本数据类型和引用型数据类型，其中，基本数据类型又包括三大类，分别为：数值型、字符型(char)和布尔型(boolean)，而其中的数值型又包括了两种类型，分别为整数型（byte.short.int.long）和浮点型(float.double)；其次，引用数据类型又包括了三大类分别是：类（class）、接口（interface）和数组（queue）.

JAVA基本运算符号

首先，java基本运算符号分为：算术运算符、关系运算符、布尔逻辑运算符、位运算符、赋值运算符、字符串连接运算符六种；

下面对这六种运算符进行详细的解释：

算术运算符包括：+ — * /   %  ++   --

关系运算符包括：>  <  >=  <= ==  !=

布尔逻辑运算符： ！ &&   | |

位运算符：& | ^ ~ << >> >>>

赋值运算符：= 扩展赋值运算符：+=   —=  *=  /=

字符串连接运算符：+

JAVA程序基本控制语句

java基本控制语句主要有分支语句和循环语句；

首先说一下分支语句，分支语句中主要说的是if语句和switch语句，在分支语句中主要有三种形式：（1）if（boolean类型表达式）语句A；功能：当表达式为真时执行语句A，否则跳过。（2）if（boolean类型表达式）语句A  else 语句B，功能是，先执行if中布尔表达式的值，如果满足便执行语句A否则执行else中的部分；（3）if（boolean类型表达式1）语句1

else (boolean类型表达式2)语句2

else (boolean类型表达式3)语句3

else   语句n;

它的功能是先执行if中的boolean表达式值，满足就执行语句1，不满足就执行else，判断else语句中的boolean表达式中的值，满足便执行语句2；以此类推，若没有满足条件的，就执行语句n;

switch语句：switch(表达式)

{    case const1:

         statementl

             break;

..........

}

最后说一下循环语句，循环语句中主要包含三种循环，while、for和do-while循环，其中do-while不经常使用；

先介绍while循环：

1、 while循环是“当“型循环。

2、 形式：while(boolean表达式) 语句

3、 执行过程：先判断表达式的值，若为true，则执行其后面的语句，然后再判断条件并反复执行，直到条件不成立为止。

4、 在不知道要循环多少次时使用while循环。

5、 While后面一般为语句块，即加：{ }

语句中应有使表达式趋于false的语句，否则会出现死循环。

在介绍一下for循环

1、 形式

for(表达式1；表达式2；表达式3) 语句

2、 执行过程

首先计算表达式1，接着执行表达式2。若表达式2的值为true 则执行语句，接着执行表达式三，再判断表达式2的值。依此重复下去，直到表达式2的值为false。

3. 表达式2一般不可省略，否则为无限循环。表达式3亦可省略，但在循环体内必须有语句改变循环变量的值，以使表达式2在某一时刻值为false而正常结束循环。也可以同时省略表达式1和表达式3

数组的概念及使用

1、数组是多个相同类型数据的组合，实现对这些数据的统一管理。

2、数组属于引用类型，数组型数据是对象（object），数组中的每个元素相当于该对象的成员变量。

3、数组中的元素可以是任意数据类型，包括基本数据类型和引用数据类型。

静态初始化：即在声明数组时直接指定数组元素。例如：Int [] a = {4,5,6,7,8,9};

动态初始化：即在声明数组时不指定数组元素，而是在之后动态指定。例如：

int [] a=new int[10];for(int i=0;i<10;i++){ a[i]=i; }

方法的声明及使用

定义方法：访问权限 返回值类型 方法名字（参数列表）{方法体}

（1）     方法的返回值类型要和return返回值类型一致；

（2）     方法调用时，实参的类型，个数，顺序要和形参类型方法中的保持一致；

（3）     在方法调用时，方法名字要和定义时的方法名字保持一致；

方法的重载

方法的重载是多态的实现手段之一，解决了命名空间问题（在类中实现相同功能的方法）

满足条件：1、方法名相同  2、方法的参数类型不同、参数个数不同或参数类型顺序不同  3、返回值类型可以相同也可以不同。（与返回值类型无关）

面向对象的概念

面向对象有三大特征：封装、继承和多态，这是面向对象的主要好处；

类的定义

定义：修饰符 class 类名{

        成员变量；

方法

}

对象的产生与使用

Java语言中使用关键字new调用构造方法来创建新对象。

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

通过对象调用方法或修改属性值。

匿名对象

不定义对象的引用名称，而直接调用方法，我们叫这样的对象是匿名对象。只能一次性使用。

使用匿名对象的好处是节省了内存空间（Java的垃圾回收机制）

如果对一个对象需要进行一次调用，可以使用匿名对象。

常用匿名对象作为一个实参传给方法调用，用完之后抛弃

实现类的封装性

面向对象的特征之一（封装、继承、多态是面向对象的三大特征）

封装主要采用private关键字实现类的封装性；，提供setXxx（）和get Xxx（）方法进行设置和返回属性值，进而达到对私有变量的设置；

构造方法的定义与使用

构造方法可以和普通方法比较来记忆，他们主要有三方面的不同，分别是定义上、作用上以及调用方式上，针对这三个不同的方面，首先从定义上说：（1）构造方法必须与类具有相同的名字，而普通方法可以是任何名字，只要符合标识符的命名规则即可；（2）构造方法不含有返回值的定义；而普通方法可以有返回值；（3）不能在构造方法中用return语句返回一个值，而普通方法在有返回值的情况下必须return一个值；其次是在作用上的不同：构造方法的主要作用是用来创建对象，同时给成员变量赋初值；而普通方法是对类的行为的描述；

最后在调用上来说，构造方法用new关键字来调用，而普通方法则是用对象名.方法名来调用；

对象的比较（“==”、“equals()”）

equals()方法在Object类中比较的是内存地址，而String类中复写了equals()方法，比较的是字符串的内容；

== 在基本数据类型中，比较的基本数据类型的值；

   在引用书籍类型中，比较的是引用（内存地址）；

在类内部调用本类方法

静态方法中可以直接调用静态方法，但不能直接调用非静态方法，需要通过对象调用。

非静态方法中可以直接调用，或使用this关键字调用。

this关键字的使用

this关键字主要有三个主要的用途：首先，this关键字用来定义属性，区分成员变量和局部变量，给局部变量赋值； this用来指代当前对象，可以用来调用方法；其次this关键字可以用来调用构造方法，用来调用构造方法时，this关键字必须放在构造方法的第一行；最后：

this不能与super关键字同时出现在构造方法中，this不能用在static修饰的方法或代码块中。

构造方法的重载

构造方法重载规则与普通方法重载一样；当采用new关键字创建对象时，会自动调用构造方法，主要用来为类中的属性初始化。每个类中都有一个默认的无参构造器，当在类中添加有参数的构造方法，则默认的构造方法遗失。

构造方法的相互调用

在本类中调用本类的构造方法时，可以使用this关键字进行调用，但是必须将此语句放在构造中的第一行，当在有继承关系的两个类中，可以在子类中使用super关键字对父类中的构造方法进行调用，但也必须将此语句放在构造方法中的第一行；this和super不能同时使用；

对象的引用传递

在Java中，参数传递分为基本类型参数传递与对象类型（即引用类型）参数传递。

基本类型参数传递意味着当将一个实参值传递给一个方法时，如果方法修改了该参数，改变的形参，而原始的实参的值保持不变。

引用类型变量传递将一个参数传递给一个方法后，方法接收的是一个引用变量的值，这个值为某个对象的内存地址值。引用变量的参数传递仍然是值传递。

static的使用（方法、属性）

static可以在变量、方法和代码块中使用；

首先，在变量前使用static是将成员变量声明为全局变量；所有对象均可访问；

其次，也可以在方法中使用static，此时这个方法被称为静态方法，可以使用类名进行直接调用，使用此方法的好处是可以节省内存空间；在一个类中，如果用静态方法去调用一个静态方法，可以直接用方法名直接调用，当在静态方法中，调用非静态方法可以使用对象名直接调用，调用静态方法是可以用类名调用也可以用方法名调用；

最后，static用于代码块时，被称为静态代码块，此代码块的优点是可以给成员变量赋初值，并且它的优先级要比main函数的优先级要高；

理解main方法

Public 表示此方法为公共的，可被外部所访问；

static 表示此方法为static方法，可被类名直接调用；

void   表示此方法无返回值；

main   系统规定的方法名称；

String【】args 表示接受运行时的参数；

对象数组的使用（静态初始化、动态初始化）

1、 声明及静态初始化：类名【】 对象名= { }；

Person[] ps = Person{ p1,p2,p3 };   //p1,p2,p3分别为Person的对象

2、声明及动态初始化  对象名【索引】=new 类名（）；

Person[] p;//对象数组声明

p=new 类名[3];//动态初始化

ps[0]=new Person();//分别对每个元素初始化

ps[0].name=”zhangsan”;

ps[0].age=13;

……

 

JDK5.0特性

类的继承

类的继承的好处是：通过继承可以减少重复代码的使用，扩展类的功能。

关键字是extends

java只支持单继承， 但是可以有多层继承；

继承是“is a”的关系。“是什么”；

子类继承父类中非private的属性和方法。

子类对象实例化时默认调用父类无参构造方法（并且放在子类构造方法首行）。

子类对象的实例化过程

当采用new关键字实例化子类对象时，首先会默认调用父类无参构造方法，接着调用子类构造方法。

方法的覆写

作用：扩展父类方法的功能。

1、 必须是在存在有继承关系的两个类中；

2、 子类方法和父类的方法名、参数、返回值类型都必须一致。

3、 要求子类方法的访问权限不能小于父类的访问权限。

4、 子类实例化父类对象，子类调用父类的方法时，会默认调用子类中覆写父类的那个方法

5、 子类继承父类的方法，访问权限只能扩大不能缩小，可用public，protected，或default，其中protected和default的区别就是后者必须在同一个包里。private的使用的好处，代码隐藏，安全；对赋值的限制。如果只是在本类中使用，不想外界得到，只要写SET方法就可以，不写GET方法（对赋值限制的体现）。

super的使用

super调用父类的属性：super.属性名;

super调用父类的方法：super.方法名（实参列表）；

调用父类中特定构造方法：super(实参列表);

调用父类中构造方法时，super（）必须放在子类构造方法的首行。this和super不能同时调用构造方法。

用super调用父类中的方法时，会调用子类中被覆写了的方法。如果子类中没有覆写父类中的方法，仍能用super调用父类中的方法

this与super的回顾对比

this用于调用本类的属性和方法，或代表当前对象。

super用于调用父类的属性和方法，必须存在于有继承关系的两个类中；

在调用构造方法时，因为两个都必须放在构造方法中的第一行，因此两个在调用构造方法时不能同时使用；

final关键字

final可以用于标记类、方法和变量

final关键字在标记类时此类不能被在继承；

final关键字在标记方法时不能被子类复写；

final修饰的变量（成员变量和局部变量）即成为常量，只能被赋值一次；

public static final 全局常量

抽象类的使用

抽象类用abstract关键字修饰。抽象类可以有实例变量、常量，也可以同时有抽象方法和具体方法，它提供一个继承的出发点，不能被实例化，但是可以通过多态性，可由其子类进行实例化。private 和static 不能声明为抽象的，子类需要复写父类所有的抽象方法；

接口的使用

接口是常量和抽象方法的集合。接口中不能有普通方法和变量。且常量必须被赋值。

接口可以实现多继承（即接口可以继承一个到多个接口，但不能继承类）

一个类可以实现多个接口；接口不能有构造方法

若extends和implements同时出现，extends必须写在implements前面

抽象类可以实现接口，并且不必实现接口中的所有抽象方法

抽象类和接口的区别

抽象类和接口是Java面向对象体系当中非常重要的两个元素，在语法方面有很多的区别，接口和抽象类在语法上的区别主要体现在以下的四个方面：

a)   一个类可以实现多个接口，而除了Object之外，一个类只能继承一个父类；

b)   接口当中所有的方法都是抽象方法，并且默认为public权限，而抽象类当中可以有抽象方法，也可以没有抽象方法

c)   接口当中的变量全部为全局常量，而抽象类当中可以定义任何类型的变量；

d)   抽象类当中有构造方法，而接口没有；

用接口实现多继承

接口不能继承抽象类，但是它可以结局单继承带来的局限性，就是多继承：

例如：Class A implements B,C,D

对象的多态性

对象的多态性表现为转型（即向上转型和向下转型）及方法的重载和复写。

1、转型：要求两个转型的对象有继承或实现关系。。

向上转型：子类对象转换成父类对象，自动转换。

           父类对象用子类实例化。

           转型后的对象不能调用子类对象特有的方法。但调用的方法为子类自身的方法。

向下转型：父类对象转换成子类对象，需要强制转换。

          只有发生过向上转型，才能发生向下转型。

2.方法的重载：方法的重载是多态的实现手段之一，解决了命名空间问题（在类中实现相同功能的方法）满足条件：1、方法名相同  2、方法的参数类型不同或参数个数不同或参数类型顺序不同  3、返回值类型可以相同也可以不同面向对象的概念

3.方法的复写：

必须是在存在有继承关系的两个类中；子类方法和父类的方法名、参数、返回值类型都必须一致。要求子类方法的访问权限不能小于父类的访问权限。子类实例化父类对象，子类调用父类的方法时，会默认调用子类中覆写父类的那个方法

对象多态性在抽象类及接口上的应用

面向接口编程的优点：1、调用者不用知道其使用对象的具体所属类

                    2、一个对象可以很容易被另一个对象（同样实现了接口）所替换

                    3、对象间的连接不必硬绑定到一个类的对象上，因此增加了灵活性

                    4、松耦合性

                    5、提高可扩展性

异常的概念

程序中的错误导致中断了正常的指令流的一种事件；通过异常处理机制，可以用一种结构化的可控方式来处理运行时的错误。在Java中所有的异常都用类来表示，并且所有的异常类都是继承自java.lang包中的Throwable类。

Throwable类有两个直接子类：Error（用来表示编译和运行错误，如程序进入死循环，内存溢出等，Error处理一般由系统承担，java本身不提供相应的Error处理机制）和Exception（用来表示由程序活动所导致的错误，如运算时除数为零等。当程序运行出现Exception时，在程序中加入异常处理代码，仍可使程序继续运行直至程序结束。由于Exception是可以检测和处理的，因此产生了相应的异常处理机制）。

try…catch语句

try代码块中是一段可能产生异常的代码；catch语句的参数包括一个异常类型和一个异常对象。该异常类型指明了catch语句所处理的异常类型，异常对象则在try中产生。{}中为对异常的处理。

与一个try相关的catch语句可以有一个或多个，异常的类型决定了要执行那个catch语句。

执行顺序：1、首先执行try代码块中的所有语句

2、 如果try{}中无异常产生，不执行catch（）{}，直接执行catch之后的语句

3、 如果try{}中有异常产生，则发生异常之后的语句不会被执行，直接跳到catch（）{}中执行。之后顺序执行。

如果catch（）{}中的异常类型与产生的不同，则执行顺序与未捕获异常一样。

throws关键字

throws用在方法的声明处，表示此方法不处理该类异常，而是交给方法的调用处处理。

throw关键字

throw用在方法的内部，用来手动的抛出异常对象。要么与try…catch一起使用，要么与throws一起使用。

finally关键字

finally必须用在异常中，不能孤立的使用，至少必须有try语句（但只有try，没有catch和finally会报错，即try，catch和finally都不能单独使用；一个try可以有多个catch；try没有catch也行，但必须要有finally；不管之前是否抛出异常，都会执行finally；现在try中加一个return语句 ，但finally仍然会执行，且先执行finally再执行return；

package的定义与使用

package的主要作用是打包，包的定义要放到java文件的最上面，打包的类文件编译是：

javac –d . 类名.java  执行的时候是：java 包名.类名 

import语句的使用

import 语句的主要作用是往程序中导入包

 

ArrayList的使用

ArrayList类封装了一个动态再分配的Object[]数组。每个ArrayList对象有一个数值，这个数值用来表示存储列表中元素的数组的容量。当元素添加到ArrayList时，这个数值会在常量时间内自动增加。