Java程序设计基础（知识点总结）
1、类：首字母大写，如果一个类名由多个单词构成，那么每个单词的首字母都大写，中间不使用任何的连接符。比如Person类，MemberTest类。
2、方法：首字母小写。如果一个方法由多个单词构成，那么第一个单词的所有字母全都小写，从第二个单词开始，每个单词的首字母大写。比如add，addThreeInt。
3、属性：命名约定与方法相同。比如age，ageOfPerson。
4、变量名命名规则:在Java中，变量名以下划线、字母、$符号开头，并且后跟下划线、字母、$符号以及数字。总之，Java中的变量名不能以数字开头
注意：在循环里可以声明变量但其是局部变量，退出循环时不可再使用。
2、单行注释：以//开头，//后面的所有内容均被当作注释处理。
多行注释：以/*开头，以*/结束，中间的所有内容均被当作注释处理。关于多行注释，需要注意的是，多行注释不能嵌套。
3、原生数据类型共有8种：整型：使用int表示。（32位）字节型：使用byte表示。（表示-128～127之间的256个整数）。短整型：使用short表示。（16位）长整型：使用long表示。（64位）单精度浮点型：使用float表示。所谓浮点型（默认情况下都是double），指的就是小数，也叫做实数，比如1.2。双精度浮点型：使用double表示。双精度浮点型表示的数据范围要比单精度浮点型大。字符型：使用char表示（char是character的缩写）。所谓字符，就是单个的字符表示，比如字母a，或者中文张，外面用单引号包围上。比如char a = ‘B’; char b = ‘张’;
布尔类型，使用boolean表示。布尔类型只有两种可能值，分别是true与false。
4、如何将double类型的值赋给float类型的变量？：强制转换的语法：类型变量名= （类型）变量值;
5、变量在使用前必须要赋值；变量必须要声明其类型方可使用；变量在使用前必须要定义，并且只能定义一次。
6、算术运算符：+、-、*、/、%、==、--。取模运算符：使用%表示。
当有若干个变量参与运算时，结果类型取决于这些变量中表示范围最大的那个变量类型。
7、关系运算符：大于（>）、小于（<）、等于（==）、不等于（!=）、大于等于（>=）、小于等于（<=），关系运算的结果是个boolean值。
8、逻辑运算符：！、&&、||、&、|、^、~。
！：操作数取反。
&：两个都true，则结果为true。
|：两个都false，则结果为false。
^:两个都同真或同假时，为false。
逻辑与：使用&&表示，逻辑与是个双目运算符（即有两个操作数的运算符），只有当两个操作数都为真的时候，结果才为真；其余情况结果均为假。逻辑与表示的并且的意思。
逻辑或：使用||表示，逻辑或也是个双目运算符，只有当两个操作数都为假的时候，结果才为假；其余情况结果均为真。
9、变量的自增与自减运算
关于int b = a++，作用是将a的值先赋给b，然后再让a自增1。
关于int b = ++a，作用是将a的值先自增1，然后将自增后的结果赋给b。
关于int b = a-- ，作用是将a的值先赋给b，然后再让a自减1
关于int b = --a，作用是将a的值先自减1，然后将自减后的结果赋给b。
10、三种流程结构：顺序结构、分支结构（或称选择结构）和循环结构。
10.1）、选择结构：if 语句、if else语句、switch语句。
A、if 语句：第一种形式：If(条件表达式) { //待执行的代码（该语句在if 后的条件语句满足时才执行。）}第二种形式：if(布尔表达式) { //待执行的代码} else { //待执行的代码}
第三种形式：if(布尔表达式) { //待执行的代码} else if(布尔表达式) { //待执行的代码} else if(布尔表达式) { //待执行的代码} else { //待执行的代码}
B、switch语句：switch(变量)
{ case 常量1:
//待执行的代码
break; //表示跳出循环。
case 常量2:
//待执行的代码
break;
case ……
default：//表示如果表达式的值与任何一个case后的常量表达式一样，则去执行default后的语句，如default语句不从在则跳出循环。
//待执行的代码}
10.2）、Java中的循环控制语句一共有3种，分别是while，do…while以及for循环。
A、for循环（使用最多的一种循环），形式为：
for(变量初始化; 条件判断; 步进)
{ //待执行的代码}
//for循环的执行过程：a）执行变量初始化。b）执行条件判断。如果条件判断结果为假，那么退出for循环，开始执行循环后面的代码；如果条件判断为真，执行for循环里面的代码。c）执行步进。d）重复步骤。
B、while循环：while(布尔表达式) { //待执行的代码} //先判断表达是真假，只要条件为真就一直循环，直到条件为假时才跳出循环。
C、do…while循环，形式为：do { //待执行的代码} while(布尔表达式);// 先执行do中的语句在判断真假，若为真就循环，当变假就跳出。
11、break语句：经常用在循环语句中，用于跳出整个循环，执行循环后面的代码。
continue语句：经常用在循环语句中，用于跳出当前的这个循环（或者是跳出本次循环），开始下一次循环的执行。
return语句：是程序从方法中返回，并返回一个值。
12、类是一种抽象的概念，类中包含了数据（通常使用名词来表示，在类中称作属性或者叫成员变量）与对数据的操纵（通常使用动词来表示，这种操纵在类中称作方法）
13、对象是一种具体的概念，是类的一种具体表示方式。
14、面向对象程序设计的三大基本特征：继承、封装、多态
封装：类包含了数据与方法，将数据与方法放在一个类中就构成了封装。
15、类的定义：修饰符class 类的名字{ //类的内容（包含了属性与方法）}
16、方法的定义：修饰符返回类型方法名称（[参数1，参数2，参数3…]）{ //方法体}
注意：1）方法定义不能嵌套，也就说不能在一个方法中定义另外一个方法。方法只能定义在类中。
2）方法的执行：首先需要定义方法，接下来就可以使用方法（调用方法），当方法调用完毕后，方法可以返回值。方法到底是否返回值是由方法的定义决定的。
3)如果一个java源文件中定义了多个类，那么这些类中最多只能有一个类是public的，换句话说，定义的多个类可以都不是public的。Main方法要放在public类中，如果没有public类，那Main方法放在哪个类中都可以。
Eg：
17、生成对象：通过类来生成对象（通常使用new关键字来生成对象），生成一个对象的过程又叫做实例化。
格式：类名对象变量名= new 类名();
注意：1）一个类可以生成多个对象（实例）
2)引用类型：指向对象的变量(存放对象地址)
3)1、原生数据类型(基本类型)的变量(如：int a = 5;)和引用类型的变量都是在栈内存中分配空间。2、堆内存用于存放由new创建的对象。
18、方法的调用:
方法调用的形式是：对象变量.方法名([参数值1，参数值2，参数值3….]);
注意：用“. ”号来连接对象变量和方法名
19、注意事项
1）在方法定义中，方法的返回类型与return后面的变量或常量类型保持一致。
2）在方法调用时，给方法传递的参数需要与方法定义时的参数保持一致（参数个数一致，参数类型一致）。20、3）方法定义时的返回类型与接收方法返回值的变量类型保持一致。
public int add(int a, int b) {return a + b; }
方法定义时的参数叫做形式参数。int a = test.add(8, 3);
方法调用时所赋予的具体值叫做实际参数。
4）关键字void表示方法没有返回值。
如果方法没有返回值，那么声明方法的时候使用void关键字。方法体内有两种情况实现不返回值：
a) 不使用return语句。
b) 使用return，但return后面没有任何值或者变量，return后面只有一个分号，表示退出方法，返回到方法的调用端。
使用方式：return;
21、定义在类中的属性，叫做成员变量；而定义在方法中的属性叫做局部变量。
22、定义属性:修饰符类型属性名称;
例：public class Person
{
int age;
}
23、与方法一样，使用.运算符。首先需要生成类的实例，然后使用实例+”.”的方式来使用属性。例：Person person = new Person();
person.age
24、成员变量与局部变量的联系与区别;1)、无论是成员变量还是局部变量，使用前都需要声明（定义）。2）、从变量在内存中生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而产生，随着方法调用的结束而自动消失。
3）、对于局部变量来说，使用前必须要初始化；对于成员变量来说，使用前可以不初始化。
1）byte、short、int、long类型的初始值为0
2）float、double类型的初始值为0.0
3）char类型的初始值‘\u0000’表示的意思就是空字符。
4）boolean类型的初始值为false
25、引用类型是用在对象上的。它指向一个对象，它的值是它所指向的对象在内存中的地址。
一个对象可以被多个引用所指向，但同一时刻，每个引用只能指向唯一的一个对象。
如果一个对象被多个引用所指向，那么无论哪个引用对对象的属性进行了修改，都会反映到其他的引用当中。26、构造方法（Constructor）：构造方法用于完成对象属性的初始化工作。
3.6.1 构造方法的特点
a) 构造方法的名字必须与类名完全一致（包含大小写）
b) 构造方法没有返回值，连void也不能出现。
c) 如果在定义一个类的时候，没有为类声明构造方法，那么Java编译器会自动为类添加一个没有参数且方法体为空的构造方法（默认的构造方法）
d) 如果在定义一个类的时候，为类声明了构造方法，那么Java编译器就不会再为类添加构造方法了。
e) 不能显式调用类的构造方法，构造方法通常是通过new关键字隐式调用。
3.6.2 new关键字在生成对象时完成了三件事情
a) 为对象开辟内存空间。
b) 调用类的构造方法。
c) 将生成的对象的地址返回。
构造方法没有参数且方法体为空。
使用new来生成对象的时候，后面的小括号()表示构造方法的参数列表，如果构造方法不接收参数，那么小括号中的内容为空；如果构造方法接收参数，那么小括号中的实际参数就需要与构造方法定义中的形式参数保持一致（参数数量一致、参数类型一致、按照顺序逐一赋值）。
注意：
1）如果一个类包含了属性与方法，那么该类的每一个对象都具有自己的属性，但无论一个类有多少个对象，这些对象共享同一个方法。
2）关于方法参数传递的总结：对于Java中的方法参数传递，无论传递的是原生数据类型还是引用类型，统一是传
值（pass by value）。
3）什么类型的引用就能指向什么类型的对象，比如People类型的引用就能指向People类型的对象，但不能指向Student类型的对象。
比如：
People people = new People(); // 正确
People people = new Student(); //错误
27、第四章：
28、继承：定义：Java是单继承的，意味着一个类只能从另一个类继承（被继承的类叫做父类【基类，base class】，继承的类叫做子类），Java中的继承使用extends关键字。
格式：class 类名extends 类名
注意：
1）父类有的，子类也有
2）父类没有的，子类可以增加
3）父类有的，子类可以改变
4）构造方法不能被继承
5）方法和属性可以被继承
6）在定义一个类的时候，如果没有显式指定该类的父类，那么该类就会继承于https://www.doczj.com/doc/63287658.html,ng.Object类（JDK提供的一个类，Object类是Java中所有类的直接或间接父类）。
29、方法的重载（overload）：
同一个类中，定义了两个或多个方法名字相同，但方法参数不同，这就表明了方法间的重载关系。方法参数不同有两层含义：1）参数个数不同。2）参数类型不同。注意：方法的返回值对重载没有任何影响。
30、方法的重构（Override）：
31、如果在子类中定义的方法与其直接超类（父类）的某个方法有相同的名称和参数，则称该子类重构了该超类（父类）的该方法。
注意：方法重构与方法重载之间的关系：重载发生在同一个类内部的两个或多个方法。重构发生在父类与子类之间。
父类型的引用可以指向子类的对象。
32、一共有两种类型的强制类型转换：
33、abstract ：
向上类型转换（upcast）：比如说将Cat 类型转换为Animal 类型，即将子类型转换为父类型。对于向上类型转换，不需要显式指定。
向下类型转换（downcast）：比如将Animal 类型转换为Cat 类型。即将父类型转换为子类型。对于向下类型转换，必须要显式指定（必须要使用强制类型转换）。
34、如果一个类包含了抽象方法，那么这个类一定是抽象类。
35、如果某个类是抽象类，那么该类可以包含具体方法（有声明、有实现）。
36、如果一个类中包含了抽象方法，那么这个类一定要声明成abstract class，也就是说，该类一定是抽象类；反之，如果某个类是抽象类，那么该类既可以包含抽象方法，也可以包含具体方法。
37、无论何种情况，只要一个类是抽象类，那么这个类就无法实例化。
38、在子类继承父类（父类是个抽象类）的情况下，那么该子类必须要实现父类中所定义的所有抽象方法；否则，该子类需要声明成一个abstract class。
39、static修饰属性：无论一个类生成了多少个对象，所有这些对象共同使用唯一一份静态的成员变量；一个对象对该静态成员变量进行了修改，其他对象的该静态成员变量的值也会随之发生变化。如果一个成员变量是static的，那么我们可以通过类名.成员变量名的方式来使用它（推荐使用这种方式）。
40、static修饰方法：static修饰的方法叫做静态方法。对于静态方法来说，可以使用类名.方法名的方式来访问。
注意：不能在静态方法中访问非静态成员变量；可以在静态方法中访问静态的成员变量。可以在非静态方法中访问静态的成员变量。
总结：静态的只能访问静态的；非静态的可以访问一切。
41、final ：final可以修饰属性、方法、类
final修饰类：当一个类被final所修饰时，表示该类是一个终态类，即不能被继承。见实例：FinalTest 。
final修饰方法：当一个方法被final所修饰时，表示该方法是一个终态方法，即不能被重写（Override）。见实例：FinalTest2
final修饰属性：当一个属性被final所修饰时，表示该属性不能被改写。见实例：FinalTest3
接口的地位等同于class，接口中的所有方法都是抽象方法。在声明接口中的方法时，可以使用abstract关键字，也可以不使用。通常情况下，都会省略掉abstract关键字。
类可以实现接口。实现使用关键字implements表示，代表了某个类实现了某个接口。
一个类实现了某个接口，那么该类必须要实现接口中声明的所有方法。
Java是单继承的，也就是说某个类只能有唯一一个父类；一个类可以实现多个接口，多个接口之间使用逗号分隔。见实例：Test3
接口类型的引用可以指向实现该接口的类的实例。关于接口与实现接口的类之间的强制类型转换方式与父类和子类之间的强制类型转换方式完全一样。
42、包（package）：用于将完成不同功能的类分门别类，放在不同的目录（包）下。
1)编译带有package声明的Java源文件有两种方式：
a) 直接编译，然后根据类中所定义的包名，逐一手工建立目录结构，最后将生成的class文件放到该目录结构中（很少使用，比较麻烦）
b) 使用编译参数–d，方式为javac –d . 源文件.java，这样在编译后，编译器会自动帮助我们建立好包所对应的目录结构。
2)有两个包名，分别是https://www.doczj.com/doc/63287658.html,与https://www.doczj.com/doc/63287658.html,.dd，那么我们称后者为前者的子包
43、导入（import）：将使用package分离的各个类导入回来，让编译器能够找到所需要的类。
1)import的语法：
import com.myjjx.PackageTest1;
2)import com.myjjx.*，表示导入com.myjjx包下面的所有类。
3)import aa.bb.*并不会导入https://www.doczj.com/doc/63287658.html,包下面的类。这时需要这样写：
import aa.bb.*;
import https://www.doczj.com/doc/63287658.html,.*;
4）关于package、import、class的顺序问题：
a) 首先需要定义包（package），可选
b) 接下来使用import进行导入，可选
c) 然后才是class或interface的定义。
5）如果两个类在同一个包下面，那么则不需要导入，直接使用即可。
6）https://www.doczj.com/doc/63287658.html,ng.Object类。
https://www.doczj.com/doc/63287658.html,ng包在使用的时候无需显式导入，编译时由编译器自动帮助我们导入。
44、访问修饰符：
1）public（公共的）：被public所修饰的属性和方法可以被所有类访问。
2）protected（受保护的）：被protected所修饰的属性和方法可以在类内部、相同包以及该类的子类所访问。
3）private（私有的）：被private所修饰的属性和方法只能在该类内部使用
4）默认的（不加任何访问修饰符）：在类内部以及相同包下面的类所使用。
注：其中public和private修饰符可用在类的定义中。Public指的是所有的类都可以访问该类。Private指的是同一包下的类可以访问该类（这是java中默认的形式）。
45、String类：1、使用格式：String 字符串变量名= “字符串常量”；
2、对于String对象的相等性判断来说，请使用equals()方法，而不要使用==。
3、在“+”运算中，只要有一个String类型的，那么非String的都要把自己转换成字符串，然后进行拼接操作。
46、数组（Array）相同类型数据的集合就叫做数组
type[] 变量名= new type[数组中元素的个数];
可以按照下列方式定义长度为10的数组：
int[] a = new int[10];或者int a[] = new int[10];
数组中的元素索引是从0开始的。对于数组来说，最大的索引==数组的长度–1。
定义数组的第2种方式：
type[] 变量名= {new type[]}{逗号分隔的初始化值列表};
length属性：
Java中的每个数组都有一个名为length的属性，表示数组的长度。length属性是public，final，int的。数组长度一旦确定，就不能改变大小。
一维数组中存放原生数据类型和引用类型时的不同：
int[] a = new int[10]，其中a是一个引用，它指向了生成的数组对象的首地址，数组中每个元素都是int类型，其中仅存放数据值本身。
47、二维数组：二维数组是一种平面的二维结构，本质上是数组的数组
1)二维数组的定义方式：type[][] a = new type[2][3];
2) 二维数组的初始化：type[][] a = {｛逗号分隔的初始化值列表}，｛逗号分隔的初始化值列表｝｝;
48、第五章：
5.1输入输出流
5.1.1 File类
一个File类的对象，表示了磁盘上的文件或目录。java.io包中的File类提供了与具体平台无关的方式来描述目录和文件对象的属性功能。其中包含大量的方法可用来获取路径、目录和文件的相关信息，并对它们进行创建、删除、改名等管理工作，File类的直接父类是Object类。
输入输出流
流的概念
Java程序通过流来完成输入/输出。一个输入流能够从磁盘文件，从键盘或从网络套接字。同样，一个输出流可以输出到控制台，磁盘文件或相连的网络。
输入输出类
在java.io包中提供了60多个类（流）。
从功能上分为两大类：输入流和输出流。
从流结构上可分为字节流（以字节为处理单位或称面向字节）和字符流（以字符为处理单位或称面向字符）。
字节流的输入流和输出流基础InputStream和OutputStream这两个抽象类，字节流的输入输出操作由这两个类的子类实现。字符流是Java 1.1版后新增加的以字符为单位进行输入输出处理的流，字符流输入输出的基础是抽象类Reader和Writer
5.1.4 输入输出流的逻辑
读/写数据的逻辑为：
open a stream
while more information
read /write information
close the stream
文件的输入流（FileInputStream）
FileInputStream 是InputStream的实现类
文件的输出流（FileOutputStream ）
FileOutputStream 是OutputStream的实现类。
5.2.3 字符流
尽管字节流提供了处理任何类型输入/输出操作的足够的功能，它们不能直接操作也就Unicode字符，也就是文本文件。
字符流层次结构的顶层是Reader 和Writer 抽象类。
FileReader类
创建了一个可以读取文件内容的Reader类。FileReader继承于InputStreamReader。
FileWriter类
创建一个可以写文件的Writer类。FileWriter继承于OutputStreamWriter。
49、第六章：异常处理和GUI
6.1.1 异常
错误和异常都是错误。错误是致命的，和硬件和操作系统错误有关。而异常却是可以检测和处理的（如：除数为0，数组下标越界等）。
6.1.2 异常的处理
方案一：
try
{…}
catch(Exception e)
{…}
finally
{…}
方案二：
在调用该会产生异常的方法所在的方法声明throws Exception。
6.2.1 AWT
AWT(Abstract Window Toolkit)，抽象窗口工具包，SUN公司提供的用于图形界面编程(GUI)的类库。根据作用GUI组件可分为基本组件和容器。
1）容器：
容器其实是一种比较特殊的组件，可以容纳其它组件，如窗口、对话框等。所有的容器类都是java.awt.Container的直接或间接子类。容器不但能容纳组件，还能容纳其它容器，这一事实对于建立复杂的布局是关键的，也是基本的。2）组件：
组件又称构件，诸如按钮、文本框之类的图形界面元素。
3）布局管理器：
容器里组件的位置和大小是由布局管理器来决定的。布局管理器负责决定布局方针以及其容器的每一个子组件的大小。
①BorderLayout：
BorderLayout是Frame类的默认布局管理器，BorderLayout将整个容器的布局划分成东、西、南、北、中五个区域，组件只能被添加到指定的区域。如不指定组件的加入部位，则默认加入到Center区域，每个区域只能加入一个组件，如加入多个，则先前加入的组件会被遗弃
②FlowLayout ：
组件按照加入容器的先后顺序从左向右排列。
一行排满之后就自动地转到下行继续从左向右排列。
每一行中的组件默认设置为居中排列。
是Panel的默认布局管理方式。
小结：
Frame
–Frame是一个顶级窗口。
–Frame的缺省布局管理器BorderLayout。
Panel
–Panel无法单独显示，必须添加到某个容器中。
–Panel的缺省布局管理器为FlowLayout。
–当把Panel作为一个组件添加到某个容器中后，该Panel仍然可以有自己的布局管理器。
4）事件：
事件－描述发生了什么的对象
事件源－事件的产生器
事件处理器－接收事件、解释事件并处理用户交互的方法
① ActionEvent ：
当单击一个按钮时就会产生一个事件（ActionEvent ），然后检查是否有与该按钮关联的事件处理器（实际上就是一个方法），如果没有，那么什么都不执行；如果有，就会将该事件传递给与该按钮关联的事件处理器方法，作为该方法的参数，之后该事件处理器方法就会自动得到调用，并且该方法可以使用传递过来的 ActionEvent 对象，进而获得事件发生时与该事件及事件源相关联的那些信息。 ②WindowEvent ：
窗口事件WindowEvent 是指对窗口本身进行操作时所产生的事件，如对窗口的最小化、最大化、打开、关闭等操作。 6.2.2 Swing (实例：FrameDemo.java)
Swing ，不依赖于底层细节，轻量级的组件。是第二代GUI 开发工具它建立在AWT 之上，但用新版本的组件替代了旧版本的组件。我们经常用的有两个包： – javax.swing
– javax.swing.event
2012/11/13经济系管理信息系统教研室161.1语言简介
?1.1.1 java 简介
?Java SE ：java standard edition ?Java ME ：java micro edition
?
Java EE: java enterprise edition
2012/11/13经济系管理信息系统教研室17
1.1语言简介
?1.1.2 jdk 的下载与安装
?Jdk:java development kit （java 开发包）?Jre:java runtime environment(java 执行环境)
2012/11/13经济系管理信息系统教研室27?1.2.2第一个java 程序
public class Test {
public static vod main(String[] args){
System.out.println(“hello world!”);}}
2012/11/13经济系管理信息系统教研室28
?1.2.3 java 程序的编译与执行
Java 程序的执行过程分为两步：（1）编译：javac 文件名.java
（2）执行: java 文件名（这是一个后缀为class 的字节码文件）
2012/11/13
经济系管理信息系统教研室2
第二章：数据设计及
流程控制
2012/11/13
经济系管理信息系统教研室
3
2.1数据描述
?2.1.1 Java 中的数据类型?原生数据类型
?引用类型（对象类型）?2.1.2变量与常量
所谓常量，就是值不会变化的量；所谓变量，就是值可以变化的量。
2012/11/13经济系管理信息系统教研室42.1数据描述
?2.1.3 变量定义与赋值变量类型变量名；变量名= 变量值；int a ；a = 2；
2012/11/13经济系管理信息系统教研室5
2.1数据描述
?2.1.3 变量定义与赋值变量类型变量名= 变量值; int a = 1；
= 表示赋值，将等号右边的值赋给了左边的变量
2012/11/13经济系管理信息系统教研室
6
2.1数据描述
?2.1.4 变量名命名规则
在Java 中，变量名以下划线、字母、$符号开头，并且后跟下划线、字母、$符号以及数字。总之，Java 中的变量名不能以数字开头
2012/11/13
经济系管理信息系统教研室
7
2.1数据描述
?2.1.5 注释（见实例Variable.java ）
?单行注释：以//开头，//后面的所有内容均被当作注释处理。
?多行注释：以/*开头，以*/结束，中间的所有内容均被当作注释处理。关于多行注释，需要注意的是，多行注释不能嵌套。
?另一种多行注释。用于产生Java Doc 帮助文档。
2012/11/13
经济系管理信息系统教研室
8
2.1数据描述
?2.1.6 Java 中的原生数据类型共有8种（见实例Variable.java ）
?整型：使用int 表示。（32位）
?字节型：使用byte 表示。（表示-128～127之间的256个整数）。
?短整型：使用short 表示。（16位）?长整型：使用long 表示。（64位）
2012/11/13
经济系管理信息系统教研室9
2.1数据描述
?2.1.6 Java 中的原生数据类型共有8种（见实例Variable.java ）
?单精度浮点型：使用float 表示。所谓浮点型，指的就是小数，也叫做实数，比如1.2。
?双精度浮点型：使用double 表示。双精度浮点型表示的数据范围要比单精度浮点型大。
2012/11/13
经济系管理信息系统教研室
10
2.1数据描述
?2.1.6 Java 中的原生数据类型共有8种
（见实例Variable.java 、Variable2.java ）
?字符型：使用char 表示（char 是character 的缩写）。所谓字符，就是单个的字符表示，比如字母a ，或者中文张，外面用单引号包围上。比如char a = …B ?; char b = …张?;
?布尔类型，使用boolean 表示。布尔类型只有两种可能值，分别是true 与false 。
2012/11/13
经济系管理信息系统教研室
11
2.1数据描述
?2.1.7 变量使用过程中应注意的问题
?Java 中的所有浮点类型默认情况下都是double 。
?如何将double 类型的值赋给float 类型的变量？(1)强制类型转换，将double 类型的值强制转换为float 类型。
(2)使用java 语言的支持。如：1.2f 。强制转换的语法：
类型变量名= （类型）变量值;
2012/11/13经济系管理信息系统教研室
12
2.1数据描述
?2.1.7 变量使用过程中应注意的问题
?变量在使用前必须要赋值；变量必须要声明其类型方可使用；变量在使用前必须要定义，并且只能定义一次。
?如下代码无法通过编译：int a = 1; short b = a;
2012/11/13
经济系管理信息系统教研室
13
2.1数据描述
?2.1.7 变量使用过程中应注意的问题
?如下代码可以通过编译：short a = 1; int b = a;
总结：可以将表示范围小的值赋给表示范围大的变量；但不能直接将表示范围大的值赋给表示范围小的变量，只能通过强制类型转换实现。
2012/11/13
经济系管理信息系统教研室
14
2.2运算符与表达式
?2.2.1 算术运算符
?当有若干个变量参与运算时，结果类型取决于这些变量中表示范围最大的那个变量类型。比如，参与运算的变量中，有整型int ，有双精度浮点型double ，有短整型short ，那么最后的结果类型就是double 。
2012/11/13
经济系管理信息系统教研室
15
2.2运算符与表达式
?2.2.1 算术运算符
?取模运算符：使用%表示。(取模运算就是求余数)int a = 5; int b = 3; int c = a % b;
见实例：variable3
2012/11/13经济系管理信息系统教研室
16
2.2运算符与表达式
?2.2.2 关系运算符
?关系运算符：大于（>）、小于（<）、等于（==）、不等于（!=）、大于等于（>=）、小于等于（<=），关系运算的结果是个boolean 值。
?见实例：OperatorTest
2012/11/13
经济系管理信息系统教研室
17
2.2运算符与表达式
?2.2.3 逻辑运算符
?逻辑与：使用&&表示，逻辑与是个双目运算符（即有两个操作数的运算符），只有当两个操作数都为真的时候，结果才为真；其余情况结果均为假。逻辑与表示的并且的意思。
?逻辑或：使用||表示，逻辑或也是个双目运算符，只有当两个操作数都为假的时候，结果才为假；其余情况结果均为真。
?见实例：LogicTest
2012/11/13
经济系管理信息系统教研室
18
2.2运算符与表达式
?2.2.4 变量的自增与自减运算
?关于int b = a++，作用是将a 的值先赋给b ，然后再让a 自增1。
?关于int b = ++a ，作用是将a 的值先自增1，然后将自增后的结果赋给b 。?关于int b = a--?关于int b = --a ?见实例：Variable4
2012/11/13
经济系管理信息系统教研室19
2.2运算符与表达式
?2.2.5 条件运算符
type d = a ? b : c; 具体化形式为：int d = 2 < 1 ? 3 : 4; 见实例：Test2
2012/11/13
经济系管理信息系统教研室
20
2.3流程控制语句
?2.3.1 if 语句?第一种形式：if(布尔表达式) {
//待执行的代码}
2012/11/13经济系管理信息系统教研室21
?2.3.1 if 语句?第二种形式：
if(布尔表达式) {
//待执行的代码} else {
//待执行的代码}
2012/11/13
经济系管理信息系统教研室
22
?2.3.1 if 语句?第三种形式：
if(布尔表达式) { //待执行的代码} else if(布尔表达式) { //待执行的代码}
else if(布尔表达式) { //待执行的代码} else { //待执行的代码}?见实例：IfTest
2012/11/13
经济系管理信息系统教研室
23
2.3流程控制语句
?2.3.2 switch 语句：见实例：SwitchTest
switch(变量){ case 常量1: //待执行的代码break; default ：
//待执行的代码}
2012/11/13
经济系管理信息系统教研室
24
2.3流程控制语句
?2.3.3循环控制语句
Java 中的循环控制语句一共有3种，分别是while ，do …while 以及for 循环。
?while 循环，形式为：（见实例：WhileTest ）while(布尔表达式) {
//待执行的代码}
2012/11/13
经济系管理信息系统教研室
25
2.3流程控制语句
?2.3.3循环控制语句
?do …while 循环，形式为：do {
//待执行的代码}
while(布尔表达式); 见实例：DoWhileTest
2012/11/13
经济系管理信息系统教研室
26
2.3流程控制语句
?2.3.3循环控制语句
?for 循环（使用最多的一种循环），形式为：
for(变量初始化; 条件判断; 步进) {
//待执行的代码}
2012/11/13
经济系管理信息系统教研室
27
2.3流程控制语句
?2.3.3循环控制语句（见实例：ForTest ）
?for 循环的执行过程：a ）执行变量初始化。
b ）执行条件判断。如果条件判断结果为假，那么退出for 循环，开始执行循环后面的代码；如果条件判断为真，执行for 循环里面的代码。
c ）执行步进。
d ）重复步骤b 。
2012/11/13经济系管理信息系统教研室2第三章：java 面向对象编程
的基础（一）
2012/11/13经济系管理信息系统教研室3
3.1类与对象
面向对象程序设计（Object Oriented Programming ，OOP ；Object Oriented Design, OOD ）
?3.1.1 类
类是一种抽象的概念，类中包含了数据（通常使用名词来表示）与对数据的操纵（通常使用动词来表示）。比如说人就是一种抽象的概念，人具有姓名、年龄、身高等数据，还有吃饭、跑步等操纵数据的动作。
2012/11/13经济系管理信息系统教研室43.1类与对象
?3.1.2 对象
对象是一种具体的概念，是类的一种具体表示方式。比如说人是一个类，而张三、李四、王五等具体的人就是对象。
2012/11/13经济系管理信息系统教研室
5
3.1类与对象
?3.1.3 类所包含的内容
?a) 数据，数据在类中称作属性（Property 或者Attribute ）或者叫成员变量（Member variable ）。
?b) 对数据的操纵，这种操纵在类中称作方法（method ）。
面向对象程序设计的三大基本特征：继承、封装、多态
封装：类包含了数据与方法，将数据与方法放在一个类中就构成了封装。
2012/11/13经济系管理信息系统教研室63.2类及方法的定义
?3.2.1 类的定义
修饰符class 类的名字{
//类的内容（包含了属性与方法）}
2012/11/13经济系管理信息系统教研室7
3.2类及方法的定义
?3.2.2 方法的定义
修饰符返回类型方法名称（[参数1，参数2，参数3…]）{
//方法体}
2012/11/13经济系管理信息系统教研室
8
3.2类及方法的定义
?注意
?1）main 方法是整个Java 程序的入口点，如果类的定义中没有main 方法，则程序无法执行。?2）方法定义不能嵌套，也就说不能在一个方法中定义另外一个方法。方法只能定义在类中。
2012/11/13
经济系管理信息系统教研室
9
3.2类及方法的定义
?注意
?3）关于方法的执行：首先需要定义方法，接下来就可以使用方法（调用方法），当方法调用完毕后，方法可以返回值。方法到底是否返回值是由方法的定义决定的。
?4)如果一个java 源文件中定义了多个类，那么这些类中最多只能有一个类是public 的，换句话说，定义的多个类可以都不是public 的。Main 方法要放在public 类中，如果没有public 类，那Main 方法放在哪个类中都可以。
2012/11/13
经济系管理信息系统教研室
10
内容回忆：2012/11/13
经济系管理信息系统教研室
11
修饰符class 类的名字{
变量的定义;
修饰符返回类型方法名称（[参数1，参数2，参数3…]）{
//方法体
}}
类的内容（包含了属性与行为）
类的封装性
内容回忆：
2012/11/13
经济系管理信息系统教研室
12
class People //类的声明{
String name ；//属性，由变量实现int age ；
boolean gender ；
void speak （）{ }//行为，由方法实现void walk （）{ }
String read （String book ）{ }}
类体
例：
2012/11/13
经济系管理信息系统教研室13
类的定义（包括属性和行为的定义）
对象的实例化
对客观世界的操作与客观事物的交流
类与对象的逻辑关系
2012/11/13
经济系管理信息系统教研室
14
3.3生成对象及方法调用
?3.3.1生成对象
通过类来生成对象（通常使用new 关键字来生成对象），生成一个对象的过程又叫做实例化。public class Person { }
?格式：类名对象变量名= new 类名(); ?例：Person person1 = new Person();
请大家再生成一个Person 类的对象
2012/11/13经济系管理信息系统教研室15
例：Person person2 = new Person();
一个类可以生成多个对象（实例）
引用类型：指向对象的变量(存放对象地址)
int a = 5;
原生数据类型
比较
2012/11/13
经济系管理信息系统教研室16
例：Person person2 = new Person();
一个类可以生成多个对象（实例）
1、原生数据类型(基本类型)的变量(如：int a = 5;)和引用类型的变量都是在栈内存中分配空间。
2、堆内存用于存放由new 创建的对象。
栈内存
堆内存
a 5
引用类型：指向对象的变量(存放对象地址)
2012/11/13
经济系管理信息系统教研室17
例：Person person2 = new Person();
一个类可以生成多个对象（实例）
1、原生数据类型(基本类型)的变量(如：int a = 5;)和
引用类型的变量都是在栈内存中分配空间。
2、堆内存用于存放由new 创建的对象。
引用类型：指向对象的变量(存放对象地址)
栈内存
堆内存
p 0x3000
0x3000
0 age
.
..
new person()产生的对象
2012/11/13
经济系管理信息系统教研室
19
3.3生成对象及方法调用
?3.3.2 方法的调用
?方法调用需要通过对象来完成，方法调用的形式是：
?对象变量.方法名([参数值1，参数值2，参数值3….]);
注意：用“
.
”号来连
接对象变量和方法名
2012/11/13
经济系管理信息系统教研室
20
返回类型方法名称(参数列表)
{
//方法体(方法的实现)
}
return 返回的结果；
通过return 命令从方法返回调用方
没有返回值,使用关键字void
2012/11/13
经济系管理信息系统教研室21
int add (int x, int y){
int t=-1;
if(x>=0&&y>=0)t=x+y;return t; }
例：
class Person {
…main(…){
Person p=new Person();int t = p.add(6,9);System.out.println(t);}
定义
2012/11/13经济系管理信息系统教研室22
3.3生成对象及方法调用
?注意事项
实例：Test .java
?1）在方法定义中，方法的返回类型与return 后面的变量或常量类型保持一致。
?2）在方法调用时，给方法传递的参数需要与方法定义时的参数保持一致（参数个数一致，参数类型一致）。
2012/11/13经济系管理信息系统教研室
233.3生成对象及方法调用
?注意事项
?3）方法定义时的返回类型与接收方法返回值的变量类型保持一致。
public int add(int a, int b) {
return a + b; }
?方法定义时的参数叫做形式参数。int a = test.add(8, 3);
?方法调用时所赋予的具体值叫做实际参数。2012/11/13经济系管理信息系统教研室
24
3.3生成对象及方法调用
?注意事项
?4）关键字void 表示方法没有返回值。
?如果方法没有返回值，那么声明方法的时候使用void 关键字。方法体内有两种情况实现不返回值：
a) 不使用return 语句。
b) 使用return ，但return 后面没有任何值或者变量，return 后面只有一个分号，表示退出方法，返回到方法的调用端。?使用方式：return;
2012/11/13经济系管理信息系统教研室
273.4属性的定义和使用
?3.4.1 命名约定
?类：首字母大写，如果一个类名由多个单词构成，那么每个单词的首字母都大写，中间不使用任何的连接符。比如Person 类，MemberTest 类。
?方法：首字母小写。如果一个方法由多个单词构成，那么第一个单词的所有字母全都小写，从第二个单词开始，每个单词的首字母大写。比如add ，addThreeInt 。
?属性：命名约定与方法相同。比如age ，ageOfPerson 。2012/11/13经济系管理信息系统教研室26
3.4属性的定义和使用
?定义在类中的属性，叫做成员变量；而
定义在方法中的属性叫做局部变量。
以上述练习中的Student 类为例，增加Student 类的age 属性。
2012/11/13经济系管理信息系统教研室283.4属性的定义和使用
?3.4.2 定义属性
?修饰符类型属性名称;?例：
public class Person {
int age; }
2012/11/13经济系管理信息系统教研室29
3.4属性的定义和使用
?3.4.3 使用属性
?与方法一样，使用.运算符。首先需要生成类的实例，然后使用实例+”.”的方式来使用属性。?例：
Person person = new Person(); person.age
2012/11/13经济系管理信息系统教研室30
3.4属性的定义和使用
?3.4.4 成员变量与局部变量的联系与区别
?无论是成员变量还是局部变量，使用前都需要声明（定义）。
?从变量在内存中生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而产生，随着方法调用的结束而自动消失。
2012/11/13
经济系管理信息系统教研室
31
3.4属性的定义和使用
?3.4.4 成员变量与局部变量的联系与区别
?对于局部变量来说，使用前必须要初始化；对于成员变量来说，使用前可以不初始化。
1）byte 、short 、int 、long 类型的初始值为0 2）float 、double 类型的初始值为0.0
3）char 类型的初始值…\u0000?表示的意思就是空字符。
4）boolean 类型的初始值为false ?见实例：Person
2012/11/13经济系管理信息系统教研室
32
3.5引用类型
?引用类型：是一种数据类型，引用类型是用在对象上的。它指向一个对象，它的值是它所指向的对象在内存中的地址。
?一个对象可以被多个引用所指向，但同一时刻，每个引用只能指向唯一的一个对象。?如果一个对象被多个引用所指向，那么无论哪个引用对对象的属性进行了修改，都会反映到其他的引用当中。?
见实例：People
2012/11/13
经济系管理信息系统教研室33
3.6构造方法
?构造方法（Constructor ）：构造方法用于完成对象属性的初始化工作。?3.6.1 构造方法的特点
?a) 构造方法的名字必须与类名完全一致（包含大小写）
?b) 构造方法没有返回值，连void 也不能出现。
?见实例：PersonTest
2012/11/13
经济系管理信息系统教研室
34
3.6构造方法
3.6.1 构造方法的特点
?c) 如果在定义一个类的时候，没有为类声明构造方法，那么Java 编译器会自动为类添加一个没有参数且方法体为空的构造方法（默认的构造方法）
?d) 如果在定义一个类的时候，为类声明了构造方法，那么Java 编译器就不会再为类添加构造方法了。
?e) 不能显式调用类的构造方法，构造方法通常是通过new 关键字隐式调用。
2012/11/13经济系管理信息系统教研室35
3.6构造方法
3.6.2 new 关键字在生成对象时完成了三件事情
?a) 为对象开辟内存空间。?b) 调用类的构造方法。?c) 将生成的对象的地址返回。
2012/11/13
经济系管理信息系统教研室
36
3.6构造方法
3.6.3 默认的构造方法
?构造方法没有参数且方法体为空。
?使用new 来生成对象的时候，后面的小括号()表示构造方法的参数列表，如果构造方法不接收参数，那么小括号中的内容为空；如果构造方法接收参数，那么小括号中的实际参数就需要与构造方法定义中的形式参数保持一致（参数数量一致、参数类型一致、按照顺序逐一赋值）。
2012/11/13经济系管理信息系统教研室37
注意：
?1）如果一个类包含了属性与方法，那么该类的每一个对象都具有自己的属性，但无论一个类有多少个对象，这些对象共享同一个方法。?2）关于方法参数传递的总结：对于Java 中的方法参数传递，无论传递的是原生数据类型还是引用类型，统一是传值（pass by value ）。
\
2012/11/13
经济系管理信息系统教研室
38
注意：
?3）什么类型的引用就能指向什么类型的对象，比如People 类型的引用就能指向People 类型的对象，但不能指向Student 类型的对象。?比如：
People people = new People(); // 正确People people = new Student(); //错误?见实例：ParamTest
2012/11/13
经济系管理信息系统教研室2
第四章：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程序呢？很多人并不了解。
https://www.doczj.com/doc/63287658.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()方法 *
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入门 (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!”); } 课堂笔记
j a v a面向对象知识点总 结 Company Document number：WTUT-WT88Y-W8BBGB-BWYTT-19998
1 类和对象 类: 类是用来描述一类事物的共性内容的, 类是抽象的; 创建类,如何描述 属性功能 用变量来描述属性 用方法来描述功能 对象: 就是现实中具体的事物,对象是具体的; 创建对象 类名对象名 = new 类名(); 如何通过对象访问类中属性和方法呢 对象名.变量名 对象名.方法名(); 只要是new的对象,就是新创建的,就会在内存中开辟一段单独的空间匿名对象 创建的对象没有赋值给具体的变量; 所以给匿名对象的属性赋值是没有任何意义的; 匿名对象使用场景
1 调用方法 2 作为参数传递 3 添加进容器中 This 关键字 This. 类中的普通方法访问到的成员前边都有this.这个关键字This. 就代表当前对象, 普通方法, 创建对象调方法, 谁调用就代表谁 This(); 可以用来在构造函数中调用本类与之相对应的构造函数使用注意事项: 1 this() 只能是构造函数的第一条执行语句 2 this() 不能在构造函数之间相互调用 3 this() 不能调用自己 构造函数(方法) 构造函数的作用 用来给对象进行初始话的(初始化就是指给对象的各个属性赋值) 构造函数何时执行 对象一创建就会调用与之相对应的构造函数
构造函数语法 修饰符没有返回值类型类名(参数列表){ 具体执行的代码 } 构造函数自动添加 当一个类中我们没有明确指定构造函数的话,jvm会自动帮我们添加一个空参数的构造, 如果我们指定了,就不添加了 构造函数和普通函数的区别 执行时机不同 对象一创建就会调用与之相对应的构造函数 普通函数只有被调用才会执行 return 1 就是用来在方法中返回具体结果(结果类型必须和方法的返回值类型一致) 2 即便方法的返回值类型是void,方法中也可以出现 return; 3 构造函数中也可以有return关键字 成员变量和局部变量 1 作用范围不同, 成员变量是定义在类中的,在整个类中都起作用 局部变量是定义在方法中的,在所在代码块起作用
一、单选题 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()(
目录 第一章Jaｖa入门2? 第二章 Java基础5? 第三章条件转移1?４ 第四章循环语句20? 第五章方法 ............................................... ２6 第六章数组33? 第七章面向对象........................................... 4２第八章异常63? ? 第一章Jaｖａ入门 知识点汇总 1、JAVA 三大体系 ?Jａva ＳE：（J2SE，Jａva2 Plａtｆｏrm Ｓｔandaｒd Edｉtion,标准版），三个 平台中最核心的部分，包含Jaｖa最核 心的类库。?JａvaEＥ:(J2EＥ，Jａva 2 Platfｏｒｍ, EｎteｒpｒisｅEditiｏｎ，企业版）, 开发、装配、部署企业级应用，包含 Servlet、ＪSP、ＪａｖａＢeａn、ＪDB Ｃ、ＥJＢ、Web Ｓerｖice等。 ?Java ＭE:（J2ＭE,Jａva 2 Pｌaｔfｏr ｍMicｒo Ediｔiｏn，微型版），用于 小型电子设备上的软件开发。
2、JDK，JRＥ,JＶＭ的作用及关系 作用 ★JVM：保证Jaｖａ语言跨平台 ★JRＥ：Javａ程序的运行环境 ★ＪＤK:Jaｖa程序的开发环境 关系 ★JDK:JRE+工具 ★JRE:ＪＶM+类库 3、ＪDＫ环境变量配置 ?pａtｈ环境变量:存放可执行文件的存 放路径,路径之间用逗号隔开 ?classpａth环境变量：类的运行路径,J ＶＭ在运行时通过cｌasspａth加载需 要的类 4、重点掌握两个程序 ?javac．eｘe:Java编译器工具，可以将 编写好的Ｊava文件（．jａva）编译成 Ｊava字节码文件（．cｌaｓs）； ?javａ.ｅxe:Jaｖa运行工具，启动Jaｖa 虚拟机进程，运行编译器生成的字节 码文件(．ｃlass） 5、一切程序运行的入口 puｂｌｉｃstaｔic vｏiｄmain(Strｉng aｒgs []）｛ Syｓtem．out.ｐriｎtｌｎ（“Hel ｌo Ｗorld!”）； } 课堂笔记 练习题 一、填空题 1、Java的三个技术平台分别是（J2SE )、（Ｊ2EE)、(J2ME）。 2、Sun公司针对领域不同，提供了三个Jaｖa版本,其中对于个人计算机程序开发的是( Ｊ2SE ), 对于企业开发应用的是（J2EE)，对于嵌入式设备应用开发的是( J２ＭＥ )。 （ｃｌasｓｐａth )。 3、建立Java开发环境，安装ＪＤK,一般需要设置环境变量（path）、 4、编写一个Jａva源程序,其文件名为Teｓt．java，则编译该源程序的命令为（javac )，运行 该程序的命令为( java），生成文档注释的命令为( javadoc)。 5、Java程序的运行环境简称之为( JRE)。
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基础知识总结 写代码： 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 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)域：定义一个类时，需要定义一组称之为“域”或“属性”的变量，保存类或对象的数据。
复习题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．只能被同一个包中的类访问
第一章面向对象程序设计 一、识记知识 1.结构化程序设计思想、特点、基本过程 思想：⑴自顶向下、逐步求精； ⑵模块化； ⑶语句结构化。 特点：程序设计= 数据结构+ 算法 程序内容= 过程+ 过程调用 基本过程：软件开发的基本过程： 1)需求分析、2)系统分析、3)系统实现、4)系统测试、5)系统维护 结构化贯穿于每个过程中时，其基本过程：分解和组装 2.面向对象程序设计基本思想、特点 基本思想：以对象的观点描述分析现实世界中的问题。从普通人认识世界的观点出发，把事物归类、综合，提取共性并加以描述。 特征：1）所有待处理的内容都表示成对象； 2）对象之间依靠相互发送消息或响应消息实现通信； 3）每个对象有自己的唯一标识，以便区别属于同一个类的不同对象； 4）对象一定属于某个类，这个对象又称为所属类的一个实例； 5）类是将具有共同属性的对象进行抽象的结果，他可以具有层次关系，即一个类既可以通过继承其他类而来，又可以被其他类继承。 通过公式描述：面向对象=类+对象+继承+消息+通信 3.基本概念、面向对象的4个特性 概念： 1）抽象：从许多食物中，舍弃个别的，非本质的属性，抽取出共同的、本质的属性过程，它是形成概念的不要手段。 2）封装：指将显示世界中的某个客体的属性与行为聚集在一个逻辑单元内部的机制。 3）对象：用来描述现实世界中客体的部件，是面向对象软件系统在运行时刻的基本单位。 4）类：是一组具有相同属性特征的对象的抽象描述，是面向对象程序的有一个核心概念。（具体地说，类是面向对象程序的唯一构造单位，是抽象数据类型的具体实现，是对象的生成模板） 5）消息：是一个对象要求另一个对象实施某项操作的请求。（是对象之间相互请求或相互协作的途径，是要求某个对象执行其中某个功能操作的规格的说明） 6）继承：表达了一种对象类的相交关系。是类之间的一种常见关系，为共享数据和操作提供了一种良好的机制。 7）多态：不同的类对象收到同一个消息可以产生完全不同的响应效果。 特性：抽象性、多态性、封装性、继承性 4.消息 概念：是一个对象要求另一个对象实施某项操作的请求。是对象之间相互请求或相互协作的途径，是要求某个对象执行其中某个功能操作的规格的说明。
基础 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期末复习知识点整理 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基础测试题 一、选择题（每题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按从小到大排列
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.doczj.com/doc/63287658.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期末知识点整理总结 计科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知识点总结 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的。