Tarena_CookBook_CoreJava

Tarena

长沙

2010

Tarena_Cook_Book

CoreJava辅导资料

Logan

Java简介

Java语言是编译后再解释执行，Java源码是通过编译生成一种特殊的.class的中间字节码文件，然后再有JVM进行解释执行，JVM（Java虚拟机）是运行在操作系统中，用来屏蔽的系统间的差异。Java虚拟机处理编译后的字节码，并根据不同的系统来申请相应的资源，这样就可以保证程序的运行正常，在Java虚拟机的基础之上，由解释器来解释执行字节码文件。

Java虚拟机+解释器=JRE（Java RunTime Environment）Java运行环境

JRE+Java系统类库=JDK（Java Deveple Kit）JAVA开发工具包

Java语言特性

1. 简单性

Java 语法是C++语法的一个?纯净?版本。剔除了C++中许多很少使

用，难以理解，易混淆的特性，这里没有头文件，指针运算，结构，联

合，操作符重载，虚基类等等。

2. 安全性

Java 适用于网络/分布式环境。为了达到这个目的，在安全方面投入

了很大精力。使用java 可以构建防病毒，防篡改的系统。

3. 面向对象

面向对象设计是一种程序设计技术。它将重点放在数据（即对象）

和对象的接口上。比如：一个?面向对象的?木匠首先关注的是他制作

的椅子，第二位才是使用的工具；一个?非面向对象的?木匠则首先考

虑的是工具。

4. 平台无关

……………

JDK , JRE , JVM 基本概念

1. JDK ：是整个Java 的核心，包括了Java 运行环境，Java 工具和Java

基础的类库。

2. JRE：运行JAVA 程序所必须的环境的集合，包含JVM 标准实现及Java

核心类库。

3. JVM：它是一个虚构出来的计算机,是通过在实际的计算机上仿真模拟各种计算机功能来实现的。

Java配置环境变量

JAVA_HOME, 指明JDK安装的位置；

CLASSPATH，指明类文件的位置；

PATH，指明命令的可执行文件的位置。

例：

Unix/Linux中JAVA环境变量的配置

在（.profile(Unix) /.bash_profile(Linux) /.bashrc(Linnx)）

这些文件中作以下配置

JAVA_HOME=xxx/xxxx (指定JDK的安装目录)

CLASSPATH=. (指定类文件的所在位置，类路径)

PATH=…:$JAVA_HOME/bin:. (指明JAVA需要使用的命令的位置)

Java基本特点

①Java是一种纯面向对象的语言，在Java中所有的方法必须写在class（类）中,包括main方法。Java源文件都是以?.java?为后缀的。

②java源文件的文件名必须和Java源文件中定义的public class（公开类）的类名相同。在Java源文件中只能写一个public class（公开类），一个Java源文件中可以写多个class（类），也可以在一个类中写另一个类，这是内部类的写法，在以后的

课程中会讲到，一般我们在源文件中的类是并列的，也就是：

public class Test1{}

class Test2{}

③Java中的（package）包，是一种特殊的目录结构，他会要求编译好的文件在指定的目录结构中，要使用包时需要使

用package关键字

注意：package关键字必须出现在代码的第一行，下面的代码中写了包，编译之后的.class 文件需要在/test/java下，并且包

在一个Java源文件中只能定义一个

例：第一个Java程序

package test.java; //java中的一种用以区分同名类的设置——包

public class HelloWorld{

public static void main(String[] args){ //主方法，JVM主线程

System.out.println("Hello world")；

}

}

相应的在写完源代码保存的文件名必须和原码中写的public class后写的类名一致，也就是HelloWorld.java

java源代码中的main方法的定义写法。main方法是程序的入口。

public static void main(String[] args){

System.out.println("Hello world");

}

java源文件也要先编译，使用javac xxx.java格式的命令得来编译，要运行一个java程序时，需要使用java命令，java 类名，运行编译后的字节码（.class）文件。定义包结构要放在有效代码的第一行，package xxx.xxx，包的定义在一个程序中只能由一个，在加上包定义之后编译可以使用javac -d 路径xxxx.java,这个-d这个命令行的参数可以指定包结构的位置?.?代表当前目录。在运行时要使用类的全限定名。

java xxx.xxx.xxxx用包名以点分隔。运行时要在包结构的上一层目录来运行。package xxx.xxx; 定义包名

public class Xxx{}

xxx.xxx.Xxx，包名加类名，就是类的全限定名

例：

我们以上面的第一个java文件为例，那个文件中定义的类的全限定名就是

test.java.HelloWorld

接下来带包的类是需要生成在指定的目录结构中的，javac命令的–d 命令行参数可以自动生成包的目录结构

javac –d . HelloWorld.java （–d . 指定包结构生成在当前目录中）

java test.java.HelloWorld

注意：在运行有包的类文件时，一定要在包的所在的目录

import 关键字

在使用其他包中的类文件，在类中，可以不必写全限定名直接写类名就可以了，标明导入类的全限定名。

package关键字的使用

例1：

package test1.a;

public class Test{

}

import test1.a.*;

public class Test2{

static public void main(String[] args){

Test t=new Test();

}

}

import关键字的使用

例2：使用JAVA类库中的类

package test.java;

import java.util.*;

public class Test{

public static void main(String[] args){

ArrayList al=new ArrayList();

//不是用import就要写成这样

java.util.ArrayList list=new java.util.ArrayList();

/*

ArrayList是在java.util包中的一个类，所以在代码中需要导入使用import关键字，import xxx.xxx.Xxxx，导入包，从而不必再写类的全限定名，而只写类名就可以了。ArrayList是一个类似于C++中模板容器的类

*/

}

}

注意：系统会在每个java程序中隐含导入了https://www.360docs.net/doc/f214753506.html,ng这个包。

Java的常用package（包）

https://www.360docs.net/doc/f214753506.html,ng包，这是一个基础包。

java.util包, 这个包是工具类的包。

java.io包, 这个包是用于输入输出操作的

https://www.360docs.net/doc/f214753506.html,包, 这个包是用于网络编程。

java.awt，java.swing,javax.swing java.event包，这些包用于java的图形编程用的包。applaction java的应用程序，java应用程序中必须有一个main()方法。

Java程序的运行过程

Java程序的运行过程，执行java命令后，首先是启动java虚拟机，然后就是去找.class文件，并进行加载，先是从系统的类库中找（系统之会在跟目录下查找，所以需要完整类名），如果找不到的话会去CLASSPATH所设置的目录去找。然后加

载到java虚拟机中。

java注释

单行注释//......

多行注释/* .......*/

文档注释/** ........

(换行标签)*/,用javadoc命令可以根据原码中的文档注

释生成注释文档（html格式）。文档注释中可以

使用html标签。

javadoc -d 路径（指定注释文档的保存路径）

文档注释一般写在类定义之前，方法之前，属性之前。

在文档注释中可以用@author 表示程序的作者，@version 表示程序的版本，前两个注释符号要写在类定义之前，用于方法的注释@param 对参数进行注释,@return 对返回值进行注释@throws对抛出异常的注释。

例：

package liucy.test;

/**

*这是一个用于演示javadoc使用方法的类

*@author liucy

*@version 1.0

*/

public class JavaDocTest{

/**

*main 是程序执行的入口，他向屏幕打印?Hello?

*@param args 用于保存命令行参数

*@return main 函数不需要返回类型

*@exception main函数没有抛出任何异常

*/

public static void main( String args[] ){

System.out.println( "Hello world" );

}

}

标识符（变量名）和关键字

Java代码中的?；?、?{}?、??

Java语句以分号分隔，Java代码（除包、类的定义和import之外）是包含在大括号内，忽略空格。

标识符

1) 用以命名类、方法和变量、以及包遵守JAVA的命名规范类以每个单词都以大写字母开头。方法和变量第一个字母不大写，常量名都大写，包名都用小写字母。

2) 只能以字符、?_?或?$?开头，可以使用数字，字符以及?_?、?$?作为变量名的组成部分，且Java的标识符是大小写敏感

3) 无长度限制。

4）可以使用中文作为标识符，不可以使用关键字作为标识符。

正确的标识符：_abc , $234 , For?注意Java是大小敏感的，所以这个For不是关键字?错误的标识符：234ad ?不能以数字开头?，do ?do是关键字不可用?

goto，?goto虽然不是关键字，但是作为保留字也是不可以用作标识符的?

Java中的关键字

Java中大部分的关键字是和C++相同的但是也有些许的修改，以下是需要注意的地方。1）goto和const在java中虽然不再使用但是还作为关键字存在

2）java中没有sizeof这个关键字了，java中的boolean类型的值只能用true和false，且这两值是不能用作命名的。

3）java语言中没有无符号这个关键字（unsigned）

Java中的一种特殊文件—jar包

jar命令用于打一个xxx.jar文件

用法：jar {ctxu}[vfm0Mi] [jar-文件] [manifest-文件] [-C 目录] 文件名...

选项：

-c 创建新的存档

-t 列出存档内容的列表

-x 展开存档中的命名的（或所有的〕文件

-u 更新已存在的存档

-v 生成详细输出到标准输出上

-f 指定存档文件名

-m 包含来自标明文件的标明信息

-0 只存储方式；未用ZIP压缩格式

-M 不产生所有项的清单（manifest〕文件

-i 为指定的jar文件产生索引信息

-C 改变到指定的目录，并且包含下列文件：

如果一个文件名是一个目录，它将被递归处理。

清单（manifest〕文件名和存档文件名都需要被指定，按'm' 和'f'标志指定的相同顺序示例1：将两个class文件存档到一个名为'classes.jar' 的存档文件中：

jar cvf classes.jar Foo.class Bar.class

示例2：用一个存在的清单（manifest）文件'mymanifest' 将foo/ 目录下的所有文件存档到一个名为'classes.jar' 的存档文件中：

jar -cvfm classes.jar mymanifest -C foo/ .

一般在使用使用jar cvf 文件名.jar 文件所在路径（xxx/xxx/xxx.class）也可以压缩一个目录,只要在制定路径是指定为

文件夹，jar命令的命令行参数在使用时可以以?-?开头，也可以不用。

Java中的变量

局部变量，定义在函数（方法）内部的变量。

例：

public class Test{

static void test(){

boolean falg=false;//falg是局部变量，他的有效范围市整个方法体

if(!falg){

int a=20;

//局部变量a，是必须进行初始化的且只在if块中有效

}

a=10;//注意，这一行是会报编译错误：未声明变量a

}

}

注意：

1，对于局部变量要先赋值后使用

2，局部变量局部有效，在定义这个变量的代码块也就是在?{}?中有效3，在重合的有效范围内，不允许两个局部变量发生命名冲突。

Java的数据类型

Java的数据类型，分为两种，基本类型和对象类型。

java的基本数据类型

整型及其兼容类型

byte 1字节8位-128到127

short 2字节16位-2^15到2^15-1

int 4字节32位-2^31到2^31-1

long 8字节64位-2^63到2^63-1

浮点类型（实型）

float 4字节32位

double 8字节64位

字符类型（UniCode编码方式）

char 2字节16位

布尔型

boolean false/true

注意：自动类型提升

a 运算符

b 对于这个表达式，

a，b中有任意一个是double型，表达运算的结果就是double型

a，b中有任意一个是float型，表达式的运算的结果就是float型

a，b中有任意一个是long型，表达式的运算的结果就是long型

a，b中没有double、float、long型，那么表达式的结果就默认提升为int型。

注意：

1) char是无符号的16位整数,字面值必须用单引号括起来‘a’，

2) 字符串是使用String的，String是类，非原始数据类型，是对象类型，字符串要用双引号??。

3) 长整型数字有一个后缀为?L?或?l?，八进制前缀为?0?，十六进制前缀为?0x?。

4) 黙认浮点类型为double。

5) float数据类型有一个后缀为?f?或?F?,double数据类型后可跟后缀?D?或?d?。

6) char类型也可以用通用转译字符，也可以使用ASCII码。可以用?\u0000?这种格式，因为char型中使用的

是unicode编码方式，?\u?后所写的是四位十六进制数。

7）Java中布尔值只能使用true和false这两的字面值，不可以使用！0和0了

注：整型值存放，正数存放原码（二进制码），负数则存放补码（原码按位取反末位加一）。

注：实型值在存储时会损失精度，所以不要直接比较两个实型值。系统默认的实型都是double型，要使用时要在数据后加个f，或者强行转换。强转（占字节数大的类型转到占字节数小的类型）时会放弃高位值只取低位值。java中的数字数据类型由占字节数小的类型到占字节数大的类型的会进行自动转换，反之则需要强行转换，char型和int型之间可以相互强制转换。char和short不能像户转换。所有基本数据类型在使用时会事先分配空间，只本身就存在空间中，在传递时，就是值传递，不是引用传递。

在类中定义的方法在返回值前加上static修饰符就可以在main方法中调用了。如果不用static那就需要在main方法中创建对象，使用对象来调用对象的方法。

public class Test{

public static void main(String[] args){

Test t=new Test();

int b=1;

int c=2;

int[] a=new int[10];

t.sqort(a);

add(b,c)

}

public int[] sqort(int[] a){

}

循环语句

for(int i=0;i

while(){}

do{} while();//注意加分号

例子：

loop:for(int i=0;i

for(int j=0;j

if(3==j){

break loop;// loop为标签只能用在循环语句中，循环

//嵌套中用于跳到外层循环

}

}

}

辨析：

int x,a=6,b=7;

x=a++ + b++; //a=7,b=8,x=13

int x=6;x=~x;// 6的二进制0110 取反得11001 再转成补码（取反加一）10111 ＝－7

break，跳出本层循环，执行后面的代码，continue，提前终止本次循环，再一次进行循环或循环条件满足或不满足后退出

循环。

break 标签名; continue 标签名;这两条语句知识表示跳出有标签的循环和提前终止本次有标签的循环，只能用在循环语句

（多层循环嵌套）中，循环嵌套中用于跳到外层循环。

注意：for循环在使用时一定要注意不要忘记()中的两个";"，死循环的写法for(;;){}或者是用while(true){}

注意：System.out.println("..."+a)在使用这个语句时，它会将其中非字符串（String）的值转换成字符串（不是所有数据类型都可以的）。

数组Array

Java中的每一个数组就是都是一个对象，数组声明是包含两个部分，分别是数组的引用和数组的空间两部分。

例：int[] a = new int[10];//构造一个可以放十个int型的数字

数组的引用数组的空间

声明数组

1) 一组相同类型(可以是类)数据的集合;

2) 一个数组是一个对象;

3) 声明一个数组没有创建一个对象;

4) 数组能以下列形式声明：

int[] i 或int i[]

Car[] c 或Car c[]

*C++中只能Car c[]

*JAVA中推荐用Car[] c;

5)数组的定义如：

int[] a（数组引用声明）=new int[10]（数组空间的声明，并把空间首地址赋值给数组的引用）

int[] a；

a=new int[20]；

创建数组

1) 创建基本数据类型数组int[] i = new int[2];

2) 创建引用数据类型数组Car[] c = new Car[100];

3) 数组创建后有初始值。

数字类型为0 布尔类型为false 引用类型为null

注意：访问没有初始化的数组中的值，是会抛出异常的（NULLpointerException）,java 中只保证一维数组的地址是连续的，二维数组实际上是一维数组中有存储了多个一维数组的引用。

初始化数组

1) 初始化、创建、和声明分开

int[] i;

i = new int[2];

i[0] = 0;

i[1] = 1;

2) 初始化、创建、和声明在同一时间

int[] i = {0,1};

Car[] c = {new Car(),new Car()};

多维数组

Java中的多维数组，其本质就是在一个数组的每个元素都是声明类型的数组

1) 有效定义

int[][] i1 = new int[2][3]; （同时给定一维，二维的空间）

int[][] i2 = new int[2][]; （给定一维的空间，二维空间待定）

i2[0] = new int[2],i2[1] = new int[3];

*C++中int[][] =new int[][3];有效

2) 无效定义

int[][] i1 = new int[][3];

3) 数组长度------------数组的属性length（在二维数组中这个属性代表第一维的长度）

int[] i = new int[5];

int len = i.length;//len = 5;

Student[][] st = new Student[4][6];

len = st.length;//len = 4;

len = st[0].length;//len = 6;

Java数组的拷贝

System.arrayCopy(Object src, int srcPos, Object dest, int destPos, int length);

src源数组，srcPos从第几位开始拷贝，dest目标数组，destPos目标数组放置的起始位置，length，表示要拷贝的长度。拷贝一个数组到另一个数组。main方法中的参数String[] args，是一个字符串数组，它是用来接收命令行参数的，注意：这个命令行参数是除了java，和类名的，所以第一个命令行参数也就是数组的第0个元素。

public class Test{

public static void main（String[] args）{

}

}

面向对象的思想

anything is Object（万物皆对象）

抽象，从对具体的对象中抽取有用信息。

对象的特征就是其固有属性，对象的方法，就是对象的行为（对象能做什么）

对象本身是简单的（功能简单），多个对象可以组成复杂的系统（对象之间

彼此调用对方的方法）

对象应当是各司其职（功能简单），各尽所能（把自己的功能作到最好）。（弱耦合性实现了前面所述的对象的特点）

对象的耦合性，是对象之间的联系，对象和系统之间的联系。对象的耦合性要尽量的弱，也就是对象之间的联系尽可能的弱，对象和系统之间的联系尽可能的弱。弱耦合性是通过统一标准来实现的。

系统的可插入性，是在系统中加入新的对象之后的系统稳定性。

对象的可替换性，是在系统中替换原有的对象之后的系统的稳定性。

对象的可重用性（复用性），即对象可否被重复使用，对象的功能越简单，复用性就越好。（对象的耦合性弱，复用性就比较强）

对象的可扩展性，即对象的方法是否可增加，可以在尽量不影响系统稳定性的情况下，增加对象的方法，这个对象的可扩展性，就越好。面向过程是先有算法，后又数据结构（怎么解决问题）面向对象是先有对象（数据结构），后有算法。（用什么做）

类是某些有着相同属性的集合的抽象。类是一个类对象的模板，对象是类的具体化。类是一个新的数据类型，类的对象。

变量，分为局部变量和在类中方法外定义的实例变量，也就是对象的属性

注意：

局部变量的作用范围是在定义他的代码块内。

局部变量要先赋值后使用。

在两个叠加的代块内不允许两个局部变量命名冲突。

如：{

int a=10;

if(a==2){

int a=20;//这样是错误的

}

}

局部变量局部优先，且在于实例变量同名时会副该局部变量。

变量，包括简单变量（原始数据类型），对象变量。

方法的定义：

1，方法的修饰符（多个修饰符出现的顺序无关）

2，方法的返回值类型

3，方法名

4，方法的参数表

5，方法中允许抛出的异常

例：

public void test (int a) throws Exception{

1，修饰符2，返回值类型3，方法名4，参数表5，抛出的异常}

注意：Java中函数的定义和实现是不分开的，java中不能在返回语句后写任何代码。java中方法的重载（overload）方法名相同，参数表不同，就是方法的重载。调用时要给出明确参数确定调用某一方法。在编译时，编译器会根据参数选择适当的方法，方法的重载也叫作编译时多态。向上就近匹配原则方法的参数表中的数据类型和调用时给出的参数类型不尽相同时（类型不尽相同是指兼容类型），会根据向上匹配的就近原则。（参数类型就近向上转化匹配）

注意：调用时要给出明确参数并确定调用某一方法，否则编译会出错。

方法重载对于调用者和对象的不同对象使用者（调用其他对象的方法）

对象（对象中的方法被调用时根据参数进行自己进行选择）

方法重载的意义，重载是为了屏蔽对象使用者调用对象的同一类方法，因参数的不同而导致的行为的不同。

例：

public class CarSpeed{

/*

Java中方法重载只需要方法名相同，参数表不同又可以

形成方法的重载。

*/

public void speed(){

System.out.println(?is 20 Km/h?)

}

public void speed(int num){

System.out.println(?is 40 Km/h?);

}

public int speed(String rodename){

System.out.println(?is 80 Km/h?)

}

public double speed(long time){

System.out.println(?is 120 Km/h?);

}

public static void main(String[] args){

short a=1；

CarSpeed s=new CarSpeed();

s.speed();

short b=9;

short c=b+a;

s.speed(20);

s.speed(?sdf?);

s.speed(a);//向上就近匹配原则而调用是int参数的那个speed

}

}

创建对象的过程，

1，分配空间

2，初始化属性

3，调用构造方法（有前提，不考虑继承关系）

构造方法的写法，没有返回值类型，而它的返回值不是void类型，构造方法的方法命名必须和类名相同。系统会在你没有重载构造方法时，默认提供一个无参的构造方法。例：

public class Car{

private int price;

public Car(){//无参构造方法

}

public Car(int price){//有参的构造方法

}

public Car(int price){

this.price=price;

}

}

注意：最好在写类时提供一个无参的构造方法。

获得对象的方式

通过new关键字（在堆空间中申请分配空间），new 类名（），可以通过这种形式获得一个对象的实例，对象的实例是无法

进行方法调用和其他的操作的，必须把的他的地址赋值给一个对象的引用，通过这个

对象的引用来访问对象

面向对象的三大特征：封装、继承、多态

Java中的封装

封装，一个对象和外界的联系应当通过一个统一的接口。

对象中的内容应当公开的公开，应当隐藏的隐藏。（对象的属性应当隐藏）一个对象的内部是透明的，把对象内部的可透明性和隐藏的特性区分开，该透明的透明，该隐藏的隐藏。

属性的封装，java中类的属性的默认访问权限不是private，是default，不加访问权限修饰符的属性和方法默认为default。隐藏该属性或方法，要加private（私有）修饰符，限制只能在类的内部进行访问。属性一般都作成私有private对于类中的私有属性，要对其给出一对方法（getXxx(),setXxx()）访问私有属性，保证对私有属性的操作的安全性。方法的封装，对于方法的封装，该公开的公开，该隐藏的隐藏。方法公开的是方法的声明（定义），即（只须知道参数和返回值就可以调用该方法），隐藏方法的实现会使实现的改变对架构的影响最小化。

封装的意义，封装会使方法实现的改变对架构的影响最小化。

完全封装，类的属性全部私有化，并且提供一对方法来访问属性。

例：

public class Person{

private int age;//属性的封装

private String name;

public String getName(){

return name;

}

public void setName(String name){

https://www.360docs.net/doc/f214753506.html,=name; //this是一个关键字，他代表的是当前对象

//这一句的意思就是为本对象的属性name进行赋值

}

public int getAge(){//方法的封装

return age;

}

private String nickname(){//方法的封装

……

}

public void setAge(int age){

this.age=age

}

}

java中的继承

继承，是对有着共同特性的多类事物，进行再抽象成一个类。这个类就是多类事物的父类。父类的意义在于可以抽取多类事物的共性。

java中的继承要使用extends关键字，java中只允许单继承，一个类只能有一个父类。

这样继承关系呈树状，体现了java的简单性。

子类只能继承在父类中可以访问的属性和方法（父类中私有的属性和方法会被继承但子类中但无法访问罢了）。

访问控制修饰符:（可以修饰属性和方法）

private修饰符，表示只有本类内部可以访问。

default修饰符，方法不加修饰符，默认为default，表示在同一个包中可以访问，父子类在同一包中，子类可以继承父类的相应内容。（可以修饰类）

protected（保护）修饰符，表示同一包中可以访问，不同包的子类也可以访问继承。public修饰符，表示公开，在任何地方都可以访问。（可以修饰类）

修饰符的权限是由上而下逐渐变宽的。

继承的意义，子类可以在父类的基础之上对父类的功能进行发展,继承使系统的耦合性降低，使对象间的联系变得松散，使多类对象间的联系可用其父类对象代替。

注意：构造方法不能被继承。

父类的属性及方法的确定：从子类的角度来看子类间的共性，所有子类都有这个属性时，应当考虑是否该放在父类中。

方法可以看作是对象的行为，类的方法是这一类的对象所共有的行为，所以应当在方法的确定时，注意是不是所有的子类型中都需要有这个方法，根据不同的子类型的该方法的不同，才覆盖这个方法。

java中方法的覆盖

子类中有和父类中可访问（可继承到子类）的同名、同返回值类型、同参数表的方法，才是覆盖了从父类继承来的方法。

注意：覆盖父类中的某个方法，子类中写的方法要和父类中的方法名、参数表、返回值类型，都相同的，权限访问修饰符比父类的方法的权限修饰符的权限要么相同，要么更宽。

注意：在jdk1.4以前要求方法的覆盖时，需要方法的返回值，参数表，方法名必须严格相同，而在jdk1.5中方法覆盖，子类的中覆盖的方法的返回值可以是父类中被覆盖的方法的返回值类型的子类型。

注意：子类覆盖父类的方法时，方法的修饰符要么相同，要么子类中的方法的修饰符表示的访问权限要宽于父类。父类中的私有方法，不能被继承到子类，子类中即使将其覆盖了也不会有多态。

覆盖的意义：对从父类中继承的方法的发展。

注意：父子类中有同名的属性不叫子类覆盖了父类的属性，这种情况较作属性的遮盖（shadow）。

例：

public class Person{

……

private int age;

public void study(){

System.out.println(?学习?);

}

}

class Child extends Person{

private int age;//属性的遮盖

public void study(){//覆盖了父类中的study（）方法

System.out.println(?在小学学习?);

}

}

public class Test{

static public void main(String[] args){

Person p=new Child();

p.study();

}

}

当构造有继承关系的对象的步骤

1，递归的构造父类的对象

2，分配空间

3，初始化本类实例变量（属性）

4，调用本类的构造方法

注意：子类对象中包含着父类的对象，父类对象加上子类对象，才是完整的子类对象的实例。在构造子类对象时，先递归的构造父类对象，会默认的调用父类的无参的构造方法，所以最好将类中无参构造方法写上。

super关键字

super()，表示在子类的构造方法中调用父类的构造方法（可以通过这种方法在子类的构造方法中初始化父类中的属性），super()只能出现在构造方法的第一句上。super(),在子类的构造方中指明构造父类时调用哪一个父类的构造方法构造父类。

super,表示一个父类的对象，可以通过super来使用父类中可以访问的方法（可以在父类中定义setXxx()，getXxx()方法来访问父类中的私有属性），super可以屏蔽父子类中同名属性的命名冲突。

例：

public class Person{

……

private int age;

private String name;

public Person(){

}

public Person(String name){

https://www.360docs.net/doc/f214753506.html,=name;

}

public void study(){

System.out.println(?学习?);

}

}

class Child extends Person{

private int age;//属性的遮盖

public Child(String name){

spuer(name);//调用父类的构造方法初始化父类的属性