JAVA知识

JA V A

说明：因为时间原因，Java整理到第十章。SQL后面也没法整理了。考试的范围不会超出书本，第一次MT的范围是学完SQL剩下部分后所有已经学过的知识。该知识整理是根据书的内容和顺序整理的。仅供参考。大家还是要看书的，基本上选择题的话大家看书后有印象好选一些。为了以后工作，还是要知道每个知识点是什么，做什么用的和怎么用的。

第一章Java介绍

关键字：Java语言的特点，类成员，数组

一、Java编程语言

Java是Sun公司开发的面向对象的编程语言(OOP，Object-oriented Programming Language)，Java的设计是为了满足平台独立的需要（如各种移动设备，不同的操作系统等），Java可以用来开发独立的应用程序和分布式网络应用程序。

1、介绍几个类型的Java应用程序：

（1）CUI程序：是操作系统控制的可执行应用程序。这些程序可以访问系统资源，如读取本机上的文件

（2）GUI程序：用于Windows环境，可以以可视化的图形用户界面与用户交互。

（3）Applets小应用程序：嵌入到网页中的，可执行的小程序。要求浏览器支持Java，Applets 对系统资源的访问是有限制的。

（4）Servlets：服务器端应用程序，用于拓展Web服务器的功能

（5）Packages：包，包含了一些类的集合，可以被不同的应用程序使用

编译器是将用编程语言编写的指令转换为机器可以理解的语言。

2、Java的特点

（1）简单：Java的很多内部功能不需要知道，如如何分配内存。

（2）面向对象：Java是面向对象的语言，所有的代码都要写在类里面，处理的都是一个个的对象，如类，接口等。它支持面向对象编程语言的特点：抽象，封装，继承和多态

（3）编译(Compiled)和翻译(Interpreted)：Java程序是先被编译，然后被翻译。编译的时候，编译器检查程序中的错误并显示。当程序编译无错误后，编译器将代码转换为字节码(Bytecode)。然后Java虚拟机(JVM,Java Virtual Machine)将字节码翻译成计算机代码，也就是计算机能够理解的代码。也就是.java文件-.class文件-计算机语言

（4）可便携(Portable)：即指可以在不同的平台，包括不同的操作系统，不同的移动设备上运行。在一个电脑上写完java程序，编译成.class文件，那么在另一台电脑上只要安装JVM 就可以运行程序了。不同的操作系统要安装匹配的JVM才行。

（5）分布式(Distributed)：Java可用于开发分布式网络应用程序。

（6）安全：Java自身的很多机制保障安全，如Applet对本地资源的访问是受限的。

3、Java的架构

（1）Java编程语言和类文件

（2）JVM，Java虚拟机:构成包括类加载器，执行引擎，即时编译器(JIT,Just in Time)

（3）Java应用程序界面(API)

4、JVM的垃圾回收机制(Garbage Collection)

在Java程序里创建对象会使用内存，当一个对象不再被使用时，垃圾回收机制会释放这些资源，从内存中清除，以循环利用内存空间，也就是垃圾回收机制。

二、类成员

1、数据类型

在我们的日常生活中，有不同的数据，如人的名字，整数，小数等，同样的，在Java 程序里，有不同的数据类型。Java里的数据类型有：

（1）原始数据类型（Primitive Type）

Java内置的简单的数据类型，包括：

类型细分存储占用空间数据范围默认值

整型字节整型byte 1字节-27~27-1 0 短整型short 2字节-215~215-1 0 整型int 4字节-231~231-1 0 长整型long 8字节-263~263-1 0

小数

浮点型float 4字节 3.4e-038~3.4e+0380.0 双精度型double 8字节 1.7e-038~1.7e+0380.0

布尔型boolean 1比特bit true或false false

字符型char 2字节单个字符null

注：1个字节是8bit,如字节整型，8位，第一位表示正负，剩下的七位可以为0或1，所以可以表示的范围是-27~27-1，如01111111表示的值是27-1=127其他类推。

虽然数据有默认值，但是还是建议大家平常养成习惯，数据先定义，赋值后在使用。（2）引用数据类型(Reference Type)

也叫非原始数据。对于原始数据类型，如int a=9;存储的直接是9这个值，而引用类型,如Button b=new Button();b存储的是b在内存中的地址。类对象，数组，枚举类型都是引用类型的数据。

（3）抽象数据类型(Abstract Type)

如String，字符串类型，从原始数据类型派生出来，但比原始数据类型有更多的功能。

2、关键字(Keyword)：

Java编程语言里面预留了一些保留字，用作关键字，如abstract,boolean,int,break等等，更多参考书1.18页。所以编程的时候不要使用这些名称定义变量。关键字都应该小写。

Java是大小写敏感的语言，如Student和student是两个不同的变量。

3、定义变量

变量用于存储和操作数据。程序里的所有变量都要先定义，然后才能使用。

3.1、变量命名惯例：不是强制性的，但是建议遵循这些惯例，提高程序的可读性。

（1）名字需要简短，有意义，中间没有空格和其他符号，可以把下划线当空格用。

（2）名称必须是唯一的。

（3）必须以字母，下划线_或者$开头，后面可以跟数字，字母，下滑线_或$符号。不能以数字开头。

（4）不能是关键字，且要区分大小写，如前所述，Student和student是不同的变量。

3.2、变量类型：

变量可以被访问的范围叫做变量范围，根据变量范围，变量有以下几类

（1）类变量(Class Variables):定义在类里，可以被该类及该类的对象访问。

（2）实例变量(Instance Variables)：定义在类里，当创建该类的对象时被创建。不同的对象的值不同。

（3）局部变量(Local Variables)：定义在方法里面，只能在该方法里使用，不能在方法外使用该变量。

（4）静态变量(Static Variables)：内存至分配一次，所有的类对象共享一个值。

（5）自动变量(Automatic Variables)：只能在定义变量的函数里访问，如果调用该方法，则变量被创建，如果退出该方法，则变量被摧毁。

3.3、变量声明和赋值

变量声明告诉编译器变量的名称，数据类型，访问范围等。

如public int Number1;//声明了一个变量Number1，类型为int型，访问范围是public，即所有的类都可以访问该变量。

int Number1;//变量声明

Number1=2;//变量赋值

4、数据类型转换

我们知道Java里有不同的数据类型，在操作的时候，如一个int型和一个float型，两个的类型不一致，则需要进行类型转换。Java支持两种类型转换：

（1）隐式转换(Implicit Conversion)：即自动转换，不需要我们做什么，但要求两种数据类型是兼容的，如int和float。

int num1=10;

float num2=20.5f;

float num3=num1+num2; //num1会被隐式转换为float型

（2）显示转换(Explicit Conversion)：如果一个数据不能隐式转换为另一种数据类型，

则我们需要进行显示转换，如String和int型。

int num1=10;

String num2="101";

int num3=num1+Integer.valueOf(num2);//此处需要把num2转换为int，然后再使用

三、数组(Array)

数组用于存储相同数据类型的数据。数组中的元素(也就是每个值)在内存中的存储是连续的，即a[0]后面跟着a[1]。我们通过数组名称和索引(从0开始)来访问数组中的元素。

1、数组类型：

（1）一维数组(One-Dimensional Array)：一行数据。

int one_dimensional[];//数组声明,类型为int，数组名称为one_dimensional

one_dimensional=new int[10]; //创建数组，分配内存，数组大小为10。

（2）多维数组(MultiDimensional Array)：如矩阵，有多行多列数据，每行的数据个数可以相同，也可以不相同。程序Array_2DArray：

四、枚举类型(Enum)

枚举类型用于存放一组常量。如存放星期，月，方向(东西南北)等，因为都是固定的，可以定以后，反复使用，且用户不能使用其他值，只能从定义中的值中选择。枚举类型用关键字enum定义。

除了在类里定义enum，我们也可以在类之前定义enum。如：

此外，和类类似，enum里也可以定义变量和方法。此处不再详述。

本章主要知识点：Java的特点，垃圾回收机制，数据类型，使用变量，数组。

第二章类和对象

关键字：类，对象，访问定界符(Access Specifier),修饰符(Modifier)

一、Java程序的结构

类(Class)和对象(Object)构成Java应用程序的基本结构。Java是面向对象的编程语言。处理的是一个个的对象，对象是类的一个实例。

如人类是一个类，我们每个人都是人类的一个实例，有自己的名字，年龄，性别等属性，还有行走，奔跑，思考，吃饭，睡觉等行为。这些属性和行为就是人类这个类的成员变量和方法。

所以一个好的习惯是将要实现的代码放到方法里，然后将方法放到类里，通过在Main 函数中创建类的对象来调用方法,这样可以提高代码的重复利用率且简化代码。

类的主要成员是变量(Variables)和方法(Methods)：类中定义了各种变量和方法，也就是封装(Encapsulation)了各种变量和方法。将变量和方法都放在类中，并定义不同的访问范围，如public,private,从而限制其他类的访问，保护数据。

二、使用类和对象

1、定义类

每个学生都有一些共同的属性，如都有名字，年龄，性别等，但是每个人的年龄，性别，名字都不一样，所以我们将共有的属性和行为总结出来，然后归纳到一起，做成一个类，这样每个学生都会有这些属性(姓名等)和行为(吃饭等)，只是每个学生的属性和行为不一样。所以我们既要有类，也要有对象。

我们使用class关键字定义一个类,如

class Student //定义了一个类，名称是Student

{

//包含的成员变量和成员方法;

String Name;

char Gender;

public void Run() {}

}

2、创建类的对象

在定义了一个学生类Student后，我们需要创建这个类的对象，如创建一个名为John的对象。

Student John; //声明了一个变量，名称为John，类型为Student

John=new Student(); //用new创建John这个对象，用new后，内存才会分配空间给John 这个对象。

也可以直接声明和创建放在一句话里，即Student John=new Student();

3、main()方法

main()方法相当于程序的入口，程序执行的时候，编译器会先寻找main方法，然后开始执行。我们可以在一个程序中定义很多个类，然后在main方法里创建各种类的对象，来访问类里面的变量和方法，从而简化代码。

main()方法的定义方式如下：

public static void main(String[] args) {执行内容;}

其中,方法是public是说明程序里的任何类对象都可以访问一个方法，static说明这个方法是属于类的，而不是其对象的方法，即我们不需要创建这个类的对象，直接通过这个类名就可以访问该方法，void说明方法没有返回值。

main方法可以定义在任何类里，但是main所在的类的名称必须和.java文件的名称一样，这样才能找到main方法的位置。

4、构造函数

我们在类里定义了变量后，要给其赋值，也就是初始化(Initialization)，比如每个学生都有自己的名字，性别和出生年月等，我们创建每个学生对象时都要将这些变量初始化。通常我们将这个工作放到一个特殊的方法中实现，也就是构造函数(Constructor)。

构造函数是一个特殊的方法，用于初始化数据。它和类有相同的名称，当我们创建该类的对象的时候，自动被调用。构造函数前面不写返回类型，它会返回一个该类的实例，而不是一个值。

当执行Student John=new Student()时,该类里的Student()方法自动被调用。

另外，我们还可以定义带参数的构造函数，这样可以在创建对象的时候传过去参数，从而初始化变量，如下例：

这样我们在创建对象的时候，如果要调用带参数的构造函数，就要传过去相应的参数。如Student Allen=new Student(“Allen”,21)，这样带参数的构造函数会自动被调用。

三、访问定界符和修饰符

1、访问定界符(Access Specifier)

Java是面向对象的语言，它将所有的变量和实现各种功能的方法封装到类里。而类里的变量和方法只有该类允许的类才能访问，所以我们需要访问界定符来限制不同的类对一个类中的变量和方法的访问权限。

包(Package)：是指类的集合，我们通常把具有类似功能的类放在一个包里，更好的管理和使用这些类。

Java中的访问界定符有：

（1）public：公共的，如果一个类里的变量和方法定义为public，则同一个包里的类和不同包里的类都可以访问该变量和方法。

（2）private：私有的，提供最大的限制。如果一个变量或方法是private的，那么其他类，不管同包还是不同包，都不能访问该变量和方法。

（3）protected：受保护的，比private的要开放一些，允许一个类的子类访问设置为protected 的变量或方法。这里的子类可以是同一个包里的子类，也可以是不同包里的子类。

（4）friendly：这是变量和方法的默认访问定界符。但是这个关键字是不存在的，通常如果我们不在方法或变量加任何界定符的话，那么默认的访问是同一个包的类可以访问该方法或变量。但是我们不能使用这个关键字，如果要定义为friendly，直接不加访问界定符即可。

2、允许的修饰符(Permitted Modifiers)

修饰符定义变量和方法在类和对象里的使用。访问定界符(Access Specifier)是用于界定变量、方法等的可访问范围，而修饰符是定义这些方法和变量可以怎样使用。

Java允许的修饰符有：

（1）static

用于修饰变量，方法和内部类，常用的是用于变量和方法。

静态(static)变量和方法是属于类的，而不是具体的对象，我们不需要创建类的对象，直接用类的名称就可以访问静态的变量和方法，所有的该类对象共享该静态方法和变量。而非静态方法和变量时属于对象的，需要创建对象然后使用，且不同的对象的变量值不同。

在静态方法所在的类里，静态方法只能访问static变量和方法。

（2）final

用于类，方法和变量之前。

定义为final的变量的值不能被改变。

定义为final的方法不能在子类里修改。

定义为final的类不能被继承(inherit)。

一个final类的变量和方法默认是final变量和方法。

（3）abstract

定义为abstract的类是抽象类，抽象类一般包含一些共有的属性和方法。抽象类不能被实例化(instantiated),即不能创建抽象类的对象。抽象类里可以有抽象方法，但是抽象方法不能有实现内容，只能有定义，如

public abstract void Display();

抽象方法的实现要在子类里完成。

（4）native

native仅用于修饰方法，它告诉编译器这个方法不是用Java，而是用其他变成语言，如C等编写的。一般我们如果用其他语言写了一些方法，想不在java里重写，直接用，可以将方法定义为native，但不推荐使用。

（5）synchronized

这个主要在后面章节线程中使用。在多线程的程序中，我们用synchronized修饰一个方法，这样当两个线程同时调用这个方法时，同一时间只有一个线程使用它，当一个线程

执行完后，另一个线程才能使用，避免资源的冲突。

第三章运算符

关键字：算术运算符，移位运算符，运算符优先级

一、运算符

1、一元运算符

主要有自加(++)和自减(--)运算符，应用到一个运算对象(Operand)上，用于将数字加1，或减1。自加和自减运算符又分为前置自加(减)和后置自加(减).

2、算数赋值运算符(Arithmetic Assignment Operator)

+=,-=,*=,/=,%=

a+=b; （相当于a=a+b）

3、逐位运算符(Bitwise Operator)

用于对数据的每个二进制位进行操作，可以用于多种数据类型，如int,short,long,char等。运算时，会首先将数据转换为对应的二进制格式，然后进行运算。位运算符有：

（1）& ：与运算,将两个数的每个二进制位做与运算，如果两个值都为1,结果为1，否则为0。以byte类型为例：

如a为7,则对应的二进制是00000111

b为2,则对应的二进制是00000010

进行&运算的结果为00000010 转为十进制是2 即7&2=2

（2）| ：或运算，如果有一个值为1，则结果为1，否则为0

如00000111

00000010

结果00000111 转换为十进制为7 即7|2=7

（3）~ ：反位运算，即0转为1,1转为0

如00000111

结果11111000 转换为十进制为-8 即~7=-8

（4）^ ：异或运算，如果两个的值不一样，则结果为1，否则为0.

如00000111

00000010

结果00000101 转换为十进制为7 即7^2=5

4、移位运算符(Shift Operator)

和逐位运算符类似，移位运算符也是对二进制位进行操作。是指将一个数的二进制位向左或向右移动指定的位数。

移位运算符有：

（1）>> ：右移，a>>n，将a的二进制形式向右移动n位，右边的位被丢弃。左边空出来的位按照原来最左边的位填充。如正数左边是0,负数最左边是1。右移运算符的结果可以直接通过a/2n得到结果。如7>>2的结果为7/22=7/4，小于等于这个数的最大整数是1，类推得到-7>>2结果为-7/22=-7/，小于等于这个数的最大整数是为-2。

正数如7>>2是00000111

每个位都右移两位,最右边两位去掉000001

然后左边两位填充0 00000001 转为十进制结果为1

负数如-7>>2是11111001

每个位都右移两位,最右边两位去掉111110

然后左边两位填充1 11111110 转为十进制结果为-2

（2）<< ：左移，a<

正数如7<<2 00000111

每个位都左移两位,最右边填充0 00011100 结果为28

负数如-7<<2 11111001

每个位都左移两位，最右边填充0 11100100 结果为-28

（3）>>> ：无符号右移运算符，a>>>n，一般用于操作32位或64位的二进制数，是将a 向右移动n位，但是不论原先最左边的位是1还是0，左边空出的位置都用0填充。

如7>>>2 7的32位表示为00000000 00000000 00000000 00000111

右移两位，左边填充0 00000000 00000000 00000000 00000001 结果为1

如-7>>>24 -7的32位表示为11111111 11111111 11111111 11111001

右移两位，左边填充0 00000000 00000000 00000000 11111111结果为255

5、instanceof 运算符

用于判断一个对象是否是一个指定类的实例。语法是：

对象名instanceof 类名称

如果结果为true，则说明是，是false，则对象不是类的实例。

二、运算符优先级(Operator Precedence) 请参考书3.23

第四章Java编程结构

关键字：条件语句(if else/switch case)，循环，方法重载，传参

一、编程结构

1、条件语句：用于判断一个条件，根据结果执行不同的操作

关系运算符：>, >=, <, <=, ==, !=

逻辑运算符：&&(与)，|| (或)，!(非)

(1)if … else

(2)switch … case 当判断结果有多种可能的时候，用switch case较方便，但是swich后面

的表达式的判断结果必须是byte,char,short或int中的一种。如double和float型的是不行的。

2、循环语句(Looping)

循环是指重复性的做一个事情，这样我们可以简化代码，如输出1-100的数字，我们不需要写一百个System.out.println();用循环可以用简短的代码实现。

（1）for循环：通常用于遍历，如数组的遍历，一般需要知道循环要执行多少次

程序的执行顺序是，先定义一个整数i，赋值为1，然后判断是否小于等于100，如果是，执行输出System.out.println(i)，然后i自加i++，至此i变为2,接着再次判断i是否<=100，以此类推。

嵌套循环(Nested Loop)

我们使用循环很多时候使用嵌套循环，如遍历二维数组等。

加强的for循环(Enhanced for)：该for循环用于遍历一个数组或集合中的所有元素，不用指定开始和结束条件。语法是：

上例中,int a是个变量，用于代表collection数组中的每一个元素。

（2）while循环：先判断条件，条件为真，才执行while里面的语句，有时候不知道需要执行多少次，可以使用while,如读文件，不知道是否到了文件末尾，用while比较合适。

（3）do…while循环：先执行，再判断，至少执行一次。

continue和break关键字

在使用Java编程结构的时候，我们会经常用到continue和break.如在循环里，continue 是跳过continue后面的语句，直接到写一次循环，而break是直接跳出循环。

continue

break

二、带参数和返回值的方法

1、带参数的方法

调用方法：Sum(10,20);)

2、带返回值的方法

调用方法int c=Sum(10,30);

//上面的a和b是方法的参数，是形式参数，此处的10和30是实际传给方法Sum()的值，称为实际参数。

3、方法重载(Method Overloading)

Java是面向对象的编程语言，所以也具有抽象,封装,继承,多态的特点。其中方法重载就是多态的一个表现。

方法重载就是一个方法名，不同的形式(签名不同)，实现类似的功能，简化代码。

签名是指一个方法的参数，它包括的内容有：方法名，参数的个数，参数的类型，参数的顺序。如Sum(int a,int b)。当调用重载方法时，编译器根据签名调用对应的方法。

以下三个方法都是Sum方法，只是签名不同，这就是方法重载。

调用的时候，根据签名调用不同的方法：

int c=Sum(10,20); //调用第一个方法。

Sum(20.5f,70f); //调用第二个方法。

Sum(10,20.5f,30); //调用第三个方法。

4、可变长度参数(Variable-Length Arguments)

Java提供了一种可变长度参数。当不知道传递给方法的参数个数时，可以使用可变长度参数。用…三个点表示：

调用： int c=Sum(10,20,30,40,50); //可以是任意个参数

三、参数传递(Passing Parameters)

如前所讲，方法可以带参数，我们可以在调用方法的时候向方法传递参数。但参数传递也有不同的方式，有按值传递(Pass by Value)和按引用传递(Pass by Reference)两种，前者是将实际参数的值copy 给方法，后者是指将实际参数的引用地址传递给方法。

1、按值传递(Passing by Value)

传参时是将变量的值copy 给方法的参数，形式参数值的改变不会引起实际参数值的改变

static void Add(int para) { para++;}

public static void Main()

{

int i=5;

Add(i); }

//按值传递,结果i 的值还是5。i 的值copy 给para

//但i 和para 指向不同的内存地址,para 的值改变了,但i 的值没变

3、 按引用传递(Passing by Reference)

传参时是将实际参数的引用地址传给方法的参数，所以形式参数的改变会引起实际参数值的改变

i 5 5自加为6 para 值copy 给para i

5 para

地址传给para

4、通过命令行传递参数

除了上面的，通过调用方法传递参数，我们也可以通过命令行向main函数传递参数。传递的方法时在cmd窗口执行java程序的时候，直接后面加上参数。

如我们有java程序Program.java。

先用javac命令编译程序，然后用java执行程序，后面跟着要传递过去的参数。

四、嵌套类(Nested Class)

顾名思义，嵌套类是指类里面的类。在某些程序里可能会用到，如在游戏里有用户，可以使用嵌套类实现。

嵌套类所在的类是封闭类(Enclosing Class)。如类B在类A里面的话，则A就是个封闭类，而B是一个嵌套类。这样，B只为A所知，其他类是看不到的。且B能访问A里面包括private成员在内的成员。而封闭类A不能访问B的成员，除非创建B的对象。

嵌套类分为static嵌套类和inner嵌套类两种。

（1）静态嵌套类(static)：是指在嵌套类前面加了static修饰符，如

public static class NestedClass

静态嵌套类不能直接访问其封闭类的成员，除非创建其对象。

（2）内部嵌套类(inner)：非静态嵌套类。可以直接访问其封闭类的成员。

第五章继承和接口

关键字：基类，子类，继承，方法覆盖(Override)，接口

一、继承(Inheritance)

面向对象的变成语言的特点之一就是继承。简单的说就是一个类可以被继承，有子类，这样子类有了父类的特征，同时又可以有自己独特的特征。如动物是一个父类，然后鸟类，人类，两栖类等都是动物类的子类。

基类/父类：是指被继承的类

派生类/子类：是指继承父类的类，继承父类后，拥有和父类一样的成员变量和成员方法。除了从父类继承的变量和方法，子类也可以定义自己的变量和方法。

Java支持的继承方式有：

（1）单层继承(Single Level Inheritance)

如A->B,A->C 即B派生自A，C也派生自A，这都是单层继承。

（2）多层继承(Multilevel Inheritance)

如A->B,B->C 即B派生自A，C又派生自B。这样C不仅继承了B的成员变量和方法，也继承了A的变量和方法。

二、方法覆盖(Overriding)

动物是一个父类，可能有很多不同的行为，如吃食习惯。如有些鸟类吃昆虫，有些吃肉。这样同样是吃食习惯，我们在子类里就要写不同的代码实现不同的吃食习惯。

方法覆盖是多态性的另一个表现。是指在子类里覆盖父类里的同名方法。

父类里的static和final方法不能被覆盖，如果试图在子类里覆盖这样的方法，编译器会报错。但是子类必须覆盖父类的abstract方法，也就是抽象方法。

类的继承通过extends(拓展)关键字实现。

public class B extends A

这样就定义了一个类B，派生自类A

例子：

父类Animal

子类Bird

在Main函数里创建Bird对象，测试继承和方法覆盖。

三、接口(Interface)

Java是不支持多重继承的，Java里一个类只能派生自一个类。所以为了实现类似多重继承，Java提供了接口(Interface)。

接口(Interface)和类类似，是一些方法和数据成员(是static且final的变量，相当于一个常量)的集合。但是接口里定义的方法都是抽象方法，即只有定义，没有执行代码。接口需要类去执行。一个类可以执行多个接口，从而实现不同的功能，但是一旦一个类执行了一个接口，就要重写接口里的所有方法，接口里的方法要是public的方法，因为需要类去执行。

接口的执行通过关键字implements实现。如：

class Frog implements ImyInterface

举个例子，水生动物有很多行为，如游泳Swim,捕食Prey，我们将这些行为定义在接口IWaterAnimalBehavior(可以养成习惯，I表示是接口，后面跟名字)中。陆生动物也有很多行为，如Crawl爬行，我们定义在接口ILandAnimalBehavior接口中。青蛙Frog是两栖动物，所以青蛙类既有水生动物的行为，又有陆生动物的行为。这样我们需要让青蛙类执行这两个接口，并重写两个接口里的所有方法。

（1）定义IWaterAnimalBehavior接口

（2）定义ILandAnimalBehavior接口

（3）定义一个类Frog，青蛙类，让其执行两个接口里的所有抽象方法。

（4）然后就可以创建Frog类的对象，并使用这些方法了。

类可以同时继承父类和执行接口。如

这样Frog类既继承了Animal的变量和方法，又要执行两个接口里的所有方法。

第六章异常处理(Exception Handling)

关键字：异常，异常类型，处理异常，try catch，抛出异常，用户定义异常

一、异常

1、异常的概念(Exception)

异常是指程序中出现的非正常情况。

Java里的程序错误分为两种：

（1）编译时错误：是编译时发现的错误。如一些语法错误，漏掉标点等。

（2）运行时错误：运行时产生的错误，如除数为0，数组出界等。异常是指程序运行时发生的错误。运行时的错误可能有内存不足，资源分配错误，无法找到文

件，网络连接问题等。

2、异常类(Exception Class)

为了处理不同的运行时错误，Java提供了很多异常类，分别用于处理不同的异常。

Throwable类是所有异常类的父类。Throwable的父类是Object类。Error(错误)和Exception(异常)是Throwable的两个子类。

Object ----> Throwable ----> Error

----> Exception

Exception类下面又包含不同的异常类，如ClassNotFoundException（未找到类），IllegalAccessException（非法访问）等。

3、Java内置异常

Java内部定义好的异常。按照其是否由Java编译器处理，内置异常分为：

（1）Checked Exception：是指除RuntimeException之外的Exception类的对象或其子类的对象。检验异常通常是由无效用户输入，网络连接问题，数据库问题等引起的。

检验异常有：

①IOException(输入输出异常)

②ClassNotFoundException(未找到类异常)

③IllegalAccessException（非法访问异常）

④InstantiationException(实例化异常，如试图创建抽象类或接口的对象时)

⑤NoSuchMethodException(无此方法异常)

（2）Unchecked Exception：因程序错误引起的是运行时错误，如参数传递无效，被0除等。

非检验异常有：

①ArithmeticException：算术异常，如被0除

②ArrayIndexOutOfBoundsException：数组出界，如数组大小为5，却访问第6个元

史上最全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程序呢？很多人并不了解。

JAVA基础知识考核含答案

精品文档 JAVA基础知识考核题 班级：姓名：成绩： 一、选择题（80分，每题2分） 1．J ava编译器的命令是（ D ） A.java B. appletviewer C. jdb D. javac 2. Java解释器的命令是（ A ） A.java B. appletviewer C. jdb D. javac 3. Java开发人员使用的开发工具包是( C ) A.JVM B. JRE C. JDK D. Eclipse 4. 下列说法正确的是（ B ） A. 使用Java语言开发的程序可以在任何平台下运行，且不需要JRE B. 使用Java语言开发的程序可以在任何平台下运行，但需要JRE C. Java虚拟机是独立的，JDK中不包含虚拟机 D. Java语言编译后是字节码文件，操作系统可直接执行 5. 下列全部是合法的Java标识符的是（ B ） A. 09stu teacher $money B _salary post123 name C case abstract final D #ID list today 6. 程序中有如下语句 final float PI = 3.14f; 下列说法正确的是（ C ） A PI 是一个变量，初始化的值是3.14. B 定义有错误，PI 是float类型3.14后不能加f C PI 是一个常量，其值是3.14 D 对PI可以重新赋值，如PI = 3.1415926; 7 下列初始化值正确的是（B ）

A float score = 90.5; B boolean flag = false; C char 慮敭?尠张三; D boolean num = 1; 8. 有如下代码 . 精品文档 class ScopeVar { public static void main(String [ ] args) { int num = 10; if ( num = = 10) { int num1 = num * num; } num1 = num1+10; System.out.println(num1); } } 输出正确的是（ D ） A 110 B 20 C 不确定 D 程序错误 9. 下面对Scanner 描述正确的是（ C ） A Scanner类提供输入数据的方法，但只能输入字符串 B Scanner的使用方法：Scanner.next(); C 使用Scanner需要导入java.util.Scanner类 D 从键盘读取一个整数的方法 Scanner sc = new Scanner(); int num = sc.nextInt(); 10. 有String str1=hello; int num=100; 则对str1+100 说法正确的是（ A ） A str1+100 的值是一个字符串hello100 B str1+100会产生语法错误，字符串不能和整数相加 C str1+100不会产生语法错误，最终的结果是100，str1的值被忽略掉 D str1+100不会产生语法错误，最终的结果是hello，100被忽略掉 11. 哪种方法返回String中的字符数( B ) A. size() B. length() C.width() D.girth() 12. 下面创建数组正确的是B A int[] int_array = int[10]; B int[] int_array = new int[10]; C int[] int_array = new int(10);

java基础知识点总结

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基础知识总结

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后，会在当前目录下查找要运行的类文件； 如果指定了classpath，那么会在指定的目录下查找要运行的类文件。 还会在当前目录找吗？两种情况： 1）：如果classpath的值结尾处有分号，在具体路径中没有找到运行的类，会默认在当前目录再找一次。 2）：如果classpath的值结果出没有分号，在具体的路径中没有找到运行的类，不会再当前目录找。 一般不指定分号，如果没有在指定目录下找到要运行的类文件，就报错，这样可以调试程序。 4，javac命令和java命令做什么事情呢？

Java基础知识点复习资料

1、classpath的设置及作用：设置为set classpath=“绝对路径”。作用是指定Java类的执 行路径。是用来寻找class文件的。 2、path的设置及作用：是内部命令。在编译Java的时候需要用到javac命令在执行java 的时候要用到java命令，这两个命令不时windows自带的命令，所以我们使用的时候要设置好环境变量，这样就可以在任何目录下使用了。 3、JA V A数据类型：基本数据类型（数值型（整型（byte.short.int.long）、浮点型 （float.double））、字符型(char)、布尔型(boolean)）、引用数据类型(class.数组、接口)。 4、JA V A基本运算符号：赋值运算符、算术运算符、关系运算符、逻辑运算符、条件运 算符、括号运算符。 5、JA V A程序基本控制语句： 1、if (判断条件) { 语句1； 语句2； } 2、if（判断条件） { 语句1； } else { 语句2； } 3、switch（表达式） { case 选择值1；语句主体1； break； case 选择值2；语句主体2； break； case 选择值3；语句主体3； break； default：语句主体； } 4、for（赋初始值；判断条件；赋值增减量） { 语句； } 5、while（判断条件） { 语句1； 语句2； } 6、do {

语句1； 语句2； } while（判断条件）； break跳出循环。continue跳出本次循环进入到下次循环。 6、数组的概念及使用：数组是由一组相同类型的变量所组成的数据类型，它们以一个共 同的名称来表示。 格式一：数据类型数组名[] 数组名=new 数据类型[个数] 例：int i[] i=new int[8] 格式二：数据类型数组名[]=new 数据类型[个数] 例：int i=new int[8] 7、方法的声明及使用：完成某一特定功能的代码块。 返回值类型方法名称（类型参数1，类型参数2） { 程序语句； return表达式； } 8、方法的重载：在同一个类中允许同时存在一个以上的同名方法，只要他们的数据类型 参数个数不同即可。 例如：public static int Test(int i,intj) { return i+j; public static int Test(int x) { return x++; } pubic static double Tset(double m,double n) { return m+n; } public static int Test(int a,int b,int c) { return a-b+c; } } 在程序中Test方法被重载了4次，但每个重载了的方法所能接受参数的个数和类型不同。 9、类的定义： 将具有相同属性及相同行为的一组对象称为类。广义的讲，具有共同性质的事物的集合就称为类。 class 类名称 {

java基础知识

一、单项选择题 1.下列正确的Java的标识符是：( A )。 A. username B. %passwd C. 3d_game D. class 2.分析下面的程序段，程序的运行结果是： ( D ) public class Example{ public static void main(String args[] ){ int l=0; do{ System.out.println(“Doing it for l is:”+l); }while(--l>0); } } A. Doing it for l is 3 B. Doing it for l is 1 C. Doing it for l is 2 D. Doing it for l is 0 3.类的实例方法所表示的是（ C ）。 A．那个类的属性 B. 那个类的行为 C.从那个类创建的对象的行为D都不对 4.main方法是Java Application程序执行的入口点，合法的定义是（ B ）。 A．public static void main（） B．public static void main（ String args[] ） C．public static int main（String [] arg ） D．public void main（String arg[] ） 5.设int x;下面哪条命令检验x的值是否等于100? ( B ) A．x.equals(100) B．x==100C．x=100 D．以上所可以 6.为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为 前缀即：AB.method( )就可以调用它，该方法头的形式为( A )。 A．static void method( ) B．public void method( ) C．final void method( ) D．abstract void method( ) 7.设有下面两个类的定义： class Person { class Student extends Person { long id; // 身份证号 int score; // 入学总分 String name; // 姓名 int getScore(){ } return score;} } 问：类Person和类Student的关系是（ C ）。 A. 包含关系 B. 关联关系 C. 继承关系 D. 无关系，上述类定义有语法错误 8.在Java中，执行下面的语句后，c的值为（ D ）。 String s= "Jessica "; char c=s.charAt(6); A. "c " B. "a " C. 'c ' D. ’a ' 9.下面哪个是java语言中的关键字？（ B ） A. sizeof B.abstract C. NULL D. Native 10.设int a＝3．b＝5，分析表达式a++-(--b)的值（ A ） A. -1 B. 0 C. 1 D.都不对

Java基础知识

实验一Java基础知识 （以下作业输入输出要求采用控制台和对话框二种方式。） 1、输入一个以秒为单位的时间量，计算所包含的小时数、分钟数和剩余的秒数，并输出。 2、编程：从键盘输入坐标图中一个点的坐标，判断它属于哪个象限。 3、中国有句俗语“三天打鱼两天晒网”，某人从2012年1月1日起三天打鱼两天晒网，编 程计算这月某日，他在打鱼还是在晒网。某日从键盘输入，打鱼则输出Y，晒网则输出N。例如3日，输入为3，输出为Y。 4、编程猜数:计算机随机产生一个[10，20]区间的整数，由人来猜。输出猜测结果是大还是 小或是正确。 5、编程：输入某年某月后，输出该月的天数。 6、输入一个double型数代表美元和美分的总钱数，然后输出与总值等价的dollar(1元)、 quarter(2角5分)、dime(1角)、nickel（5分）、和penny(1分)的数目。 7、小学生学习减法的程序。程序随机产生二个一位整数number1和number2，且满足 number1>number2。程序显示数学算式，在学生输入答案后，程序输出答案是否正确。 8、编程从键盘输入某月第一天是星期几和该月的天数，打印该月月历。 9、编制猜数字游戏程序。每次运行程序时，先用随机函数产生一个整数，范围在100以内， 然后从键盘反复输入整数进行猜数，当未猜中时，提示所猜之数过大或过小，猜中时，指出猜的次数。最多允许猜6次。 10、输入某年某月某日，判断这一天是这一年的第几天？ 11、如果一个整数的各位数之和能被9整除，则这个数也能被9整除。编程判断一个整数n是否能被9整除。其中，n由键盘输入。 12、阅读并分析程序，写出其输出结果，并上机验证。 public class BreakLabelDemo{ public static void main(String args[]){ int i,j; one: for(i=1;i<=10;i++){ System.out.print("Pass"+i+":"); for(j=1;j<=100;j++){ if(j==5)break one; System.out.print(j+"");; } } } } 13、编写一个石头剪刀布的小程序，可以使用户跟系统进行猜拳游戏。 游戏要求是：首先提示用户在石头剪刀布中间选择一个，确定后系统随机在石头剪刀布中间选择一个然后判断用户和系统哪个获胜。一局进行完后用户可以选择是否继续游戏，如果用户选择退出游戏则游戏结束。用户连续三次获胜系统提示“运气不错”后退出程序。如果连续失败三次，则提示“太倒霉了”退出程序。

JAVA基础知识考核(含答案)

JAVA基础知识考核题 班级：姓名：成绩：一、选择题（80分，每题2分） 1．J ava编译器的命令是（ D ） A.java B. appletviewer C. jdb D. javac 2. Java解释器的命令是（ A ） A.java B. appletviewer C. jdb D. javac 3. Java开发人员使用的开发工具包是( C ) A.JVM B. JRE C. JDK D. Eclipse 4. 下列说法正确的是（ B ） A. 使用Java语言开发的程序可以在任何平台下运行，且不需要JRE B. 使用Java语言开发的程序可以在任何平台下运行，但需要JRE C. Java虚拟机是独立的，JDK中不包含虚拟机 D. Java语言编译后是字节码文件，操作系统可直接执行 5. 下列全部是合法的Java标识符的是（ B ） A. 09stu teacher $money B _salary post123 name C case abstract final D #ID list today 6. 程序中有如下语句 final float PI = 3.14f; 下列说法正确的是（ C ） A PI 是一个变量，初始化的值是3.14. B 定义有错误，PI 是float类型3.14后不能加f C PI 是一个常量，其值是3.14 D 对PI可以重新赋值，如PI = 3.1415926; 7 下列初始化值正确的是（B ） A float score = 90.5; B boolean flag = false; C char name = "张三"; D boolean num = 1; 8. 有如下代码

java基础知识大全(必看经典)

第一讲 Java语言入门 1.1 Java的特点 1.1.1面向对象： ?与C++相比，JAVA是纯的面向对象的语言 C++为了向下兼容C，保留了很多C里面的特性，而C，众所周知是面向过程的语言，这就使 C++成为一个"混血儿"。而JAVA语法中取消了C＋＋里为兼容C所保留的特性，如取消了头文件、指针算法、结构、单元等。 1.1.2可移植（平台无关性）： ?生成中间字节码指令 与其他编程语言不同，Java并不生成可执行文件（.exe文件），而是生成一种中间字节码文件（.class文件）。任何操作系统，只要装有Java虚拟机（JVM），就可以解释并执行这个中间字节码文件。这正是Java实现可移植的机制。 ?原始数据类型存储方法固定，避开移植时的问题 Java的原始数据类型的大小是固定的。比如，在任何机器上，整型都是32位，而C++里整型是依赖于目标机器的，对16位处理器（比如8086），整数用两个字节表示；在像Sun SPARC这样的32位处理器中，整数用4个字节表示。在Intel Pentium处理器上，整数类型由具体的操作系统决定：对于DOS和Win32来说，整数是2个字节；对于Windows 9x 、NT和2000，整数是4个字节。当然，使整数类型平台无关之后，性能必然有所下降，但就Java来说，这个代价是值得的。Java的字符串，则采用标准的Unicode格式保存。可以说，没有这个特性，Java的可移植性也不可能实现。 1.1.3简单 ?JAVA在语法上与C++类似 JAVA的语法与C++很接近，有过C或者C＋＋编程经验的程序员很容易就可以学会JAVA语法； ?取消了C++的一些复杂而低效的特性比如：用接口技术代替了C++的多重继承。C＋＋中，一个类允许有多个超类，这个特性叫做"多重继承"，多重继承使得编译器非常复杂且效率不高；JAVA 的类只允许有一个超类，而用接口（Interface）技术实现与C＋＋的多继承相类似的功能 其它被取消的特性包括：虚拟基础类、运算符过载等 ?JAVA的基本解释器和类支持模块大概仅40K 即使加入基本的标准库和支持线程的模块，也才220K左右。与GUI（图形用户界面）相比，

Java基础知识点答案

、12、类的执行路径。作用是指定Java设置为set classpath=“绝对路径”。classpath的设置及作用：文件的。寻找class是用来 javajavac命令在执行的设置及作用：是内部命令。在编译Java的时候需要用到3、path所以我们使用的时候windows自带的命令，java命令，这两个命令不时的时候要用到要设置好环境变量，这样就可以在任何目录下使用了。型点）、浮（整型（byte.short.int.long值类型：基本数据类型（数型JA4、VA数据。数组、接口)、布尔型(boolean)）、引用数据类型(class.、字符型（float.double））(char)基本运算符号：赋值运算符、算术运算符、关系运算符、逻辑运算符、条件运AJA V5、 算符、括号运算符。程序基本控制语句：VA6、JA) 判断条件、if (1{ 1；语句2；语句} if（判断条件）2、{ 1；语句} else { 2；语句} （表达式）3、switch { ；；语句主体11 case 选择值；break 2；语句主体；case 选择值2 break； 3；选择值3；语句主体case ；break ：语句主体；default} （赋初始值；判断条件；赋值增减量）、for 4{ 语句；} 5、while（判断条件） { 语句1； 语句2； } do 、6． { ；语句1 语句2； } ；while（判断条件）跳出本次循环进入到下次循环。break跳出循环。continue 数组的概念及使用：数组是由一组相同类型的变量所组成的数据类型，它们以一个共7、同的名称来表示。[] 数组名格式一：数据类型] [个数=new 数组名数据类型 i[] int 例：

Java基础知识体系

Java基础知识体系 Java基础知识体系 (1) 1.初识JAVA (3) 2.Myeclipse的使用 (4) 3.java语法基础 (6) 4.数据类型 (8) 5.运算符 (9) 6.循环控制语句 (11) 7.Java方法 (13) 8.Java数组 (14) 9.字符串 (15)

1.初识JAVA 1.1.java概述 1.1.1.1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言，希 望用于控制嵌入在有线电视交换盒、PDA等的微处理器； 1994年将Oak语言更名为Java； 1.2.JAVA各JDK版本的特性 1.2.1.JDK5.0引入泛型 1.2.2.Java的三种技术架构 1.2.2.1.JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程 序，主要针对web程序开发 1.2.2.2.JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发， 是其它两者的基础； 1.2.2.3.JAVAME：Java Platform Micro Edition，开发电子消费产品和嵌入式设 备，如手机中的程序； 1.3.JAVA开发运行环境 1.3.1.JDK 1.3.1.1.Java Development Kit，java的开发和运行环境，java的开发工具和 jre。 1.3. 2.JRE 1.3. 2.1.Java Runtime Environment，java程序的运行环境，java运行的所需 的类库+JVM(java虚拟机)。 1.3.3.配置环境变量

java基础知识详细整理(图文并茂深入浅出)

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/794740926.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基础知识整理

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的。

java基础知识点总结

Created by Alwe n on 2017/5/14. java是面向对象的程序设计语言；类可被认为是一种自定义的数据类型，可以使用类来定义变量，所有使用类定义的变量都是引用变量，它们将会引用到类的对象。类用于描述客观世界里某一类对象的共同特征，而对象则是类的具体存在，java程序使用类的构造器来创建该类的对象。 java也支持面向对象的三大特征：圭寸装、继承、和多态。java提供了private、protected、和public 三个访问控 制修饰符来实现良好的封装，提供了extends关键字让子类继承父类，子类继承父类就可以继承到父类的成员变量和 和方法，如果访问控制允许，子类实例可以直接调用父类里定义的方法。继承是实现类复用的重要手段。使用继承关系来实现复用时，子类对象可以直接赋给父类变量，这个变量具有多态性。 面向对象的程序设计过程中有两个重要的概念：类（^?ciass）和对象（object ,也被称为实例，instanee ）。类可以包含三种最常见的成员：构造器、成员变量、和方法。 构造器用于构造该类的实例，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 修饰的成员表明它属于这个类本身，而 不属于该类的单个实例，因此通过把static 修饰的成员变量和方法被称为类变量、类方法（静态成员变量，静态成 员方法）；不使用static 修饰的成员变量和方法称为实例变量和实例方法（非静态成员变量，非静态成员方法）。 静态成员不能直接访问非静态成员。

JAVA基本知识点(适合面试)

1．面向对象的软件开发有哪些优点？ 1）把软件系统看成是各种对象的集合，这更接近人的思维。 2）软件需求的变动往往是功能的变动，而功能的执行者--对象一般不会有太大的变化。这使得按照对象设计出来的系统结构比较稳定。 3）对象包括属性和方法，对象把属性和方法的具体实现方式一起封装起来，这使得方法与之相关的属性不再分离，提高每个子系统的相对独立性，从而提高了软件的可维护性。 4）支持封装、继承、多态和抽象，提高了软件的可重用性、可维护性和可扩展性。 2．把一个类放在包里有什么作用？(包的作用) 1）能够区分名字相同的类； 2）有助于实施访问权限控制； 3）有助于划分和组织java应用中的各个类。 3．说出一些常用的类，包，接口，请各举出5个。Runable,ActionListener,Conllection,Map,Set,List接口 1）https://www.doczj.com/doc/794740926.html,ng包----包括线程类(Thread)、异常类(Exception)、系统类(System)、整数类(Integer)和字符串类(String)等，这些类是java程序中经常用到的。 2）java.awt包----抽象窗口工具箱包，awt是(Abstract Window Toolkit)的缩写。这个包中包含了用于构建GUI界面的类及绘图类。 3）java.io包----输入/输出包，包含各种输入流类和输出流类，如文件输入流类(FileInputStream类)及文件输出流类(FileOutputStream)等。 4）java.util包----提供一些实用类，如日期类(Data)和集合类(Collection)等。 5）https://www.doczj.com/doc/794740926.html,包----支持TCP/IP网络协议，包括Socket类及和URL相关的类，这些类都用于网络编程。 除了上面提到的基本包，JDK中还有很多其他包，比如用于数据库编程的java.sql包，用于编写网络程序的java.rmi包(rmi 是“Remote Method Invocation”的缩写)。另外，javax.*包是对基本包的扩展，包括用于编写GUI的javax.Swing包，以及用于编写声音程序的javax.sound包等。 4.描述一下你最常用的编程风格。 1）注意编码规则，符合编码要求； 2）变量，类等起名要有意义； 3）经常格式化代码，注意格式； 4）代码中加入测试方法或测试类，尽量提早发现错误； 5）代码中要加入注释，为别人和自己将来理解代码带来方便。 5.说一说标识符的命名规则，以及java的编程规范。 Java标识符的命名规则： 1）标识符由字母、数字、下划线“_”、美元符号“$”或者人民币符号“￥”组成，并且首字母不能是数字。 2）不能把关键字和保留字作为标识符。 3）标识符没有长度限制。 4）标识符对大小写敏感。 Java编程规范： 1）类名和接口名：首字母大写，其余字母小写。如SamDoc 2）方法名和变量名：首字母小写，其余的字母大写。如bothEyesOfDoll。

java基础知识大全(必看经典)

第一讲 Java语言入门 Java的特点 1.1.1面向对象： ?与C++相比，JAVA是纯的面向对象的语言 C++为了向下兼容C，保留了很多C里面的特性，而C，众所周知是面向过程的语言，这就使C++成为一个"混血儿"。而JAVA语法中取消了C＋＋里为兼容C所保留的特性，如取消了头文件、指针算法、结构、单元等。 1.1.2可移植（平台无关性）： ?生成中间字节码指令 与其他编程语言不同，Java并不生成可执行文件（.exe文件），而是生成一种中间字节码文件（.class 文件）。任何操作系统，只要装有Java虚拟机（JVM），就可以解释并执行这个中间字节码文件。这正是Java实现可移植的机制。 ?原始数据类型存储方法固定，避开移植时的问题 Java的原始数据类型的大小是固定的。比如，在任何机器上，整型都是32位，而C++里整型是依赖于目标机器的，对16位处理器（比如8086），整数用两个字节表示；在像Sun SPARC这样的32位处理器中，整数用4个字节表示。在Intel Pentium处理器上，整数类型由具体的操作系统决定：对于DOS和Win32来说，整数是2个字节；对于Windows 9x 、NT和2000，整数是4个字节。当然，使整数类型平台无关之后，性能必然有所下降，但就Java来说，这个代价是值得的。Java的字符串，则采用标准的Unicode格式保存。可以说，没有这个特性，Java的可移植性也不可能实现。 1.1.3简单 ?JAVA在语法上与C++类似 JAVA的语法与C++很接近，有过C或者C＋＋编程经验的程序员很容易就可以学会JAVA语法； ?取消了C++的一些复杂而低效的特性比如：用接口技术代替了C++的多重继承。C＋＋中，一个类允许有多个超类，这个特性叫做"多重继承"，多重继承使得编译器非常复杂且效率不高；JAVA 的类只允许有一个超类，而用接口（Interface）技术实现与C＋＋的多继承相类似的功能 其它被取消的特性包括：虚拟基础类、运算符过载等 ?JAVA的基本解释器和类支持模块大概仅40K 即使加入基本的标准库和支持线程的模块，也才220K左右。与GUI（图形用户界面）相比，明显小

java基础知识总结(超级经典)

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后，会在当前目录下查找要运行的类文件； 如果指定了classpath，那么会在指定的目录下查找要运行的类文件。 还会在当前目录找吗？两种情况： 1）：如果classpath的值结尾处有分号，在具体路径中没有找到运行的类，会默认在当前目录再找一次。 2）：如果classpath的值结果出没有分号，在具体的路径中没有找到运行的类，不会再当前目录找。 一般不指定分号，如果没有在指定目录下找到要运行的类文件，就报错，这样可以调试程序。 4，javac命令和java命令做什么事情呢？