Java笔记

包
自定义包：如果在程序中没有声明包，类将被存放在default的包中，default的包没有名称。不建议采用default包的形式，建议开发人员按照业务的需要创建用户自定义包。
语法：package<包名>
注意：声明一个包的语句必须写在类中的第一行。
包的导入：import<包名>.<类名>

继承
继承的概述

继承是面向对象程序设计的一个重要特征， 它是通过继承原有类派生出的子类进而构造出更为复杂的子类。子关既有新定义的行为特征，又继承了原有类的行为特征。
继承的实现

有圣剑（Sword)、长矛（Spear）、两个武器如下：

Sword类的属性:武器名（name)、攻击值（attackValue）两个武器类，

方法：攻击（attack）。

Spear类的属性:武器名（name)、攻击值（attackValue）

方法：攻击（attack）。

分析下面的程序代码，

（1）创建Sword类, 代码如下:

public (。class Sword (

String name;

//武器名

int attackValue

11攻击宿

//构造方法}
}

（2）创建Spear类，代码如下：

public Swordstring name.

this name = namame, int attackValue) (

this. attackValue 2attackValue;

//攻击方法

public void attack(0(

System out printin'武器名+name+"tr+攻击值:"+attackValue);

(2)创建Spear类，代码如下:

public class Spear 1

String name;

11武器名

int attackValue:

11攻击值

//构造方法

public SpearString name, int attackValuel|

this.name a name;

this attackValue . attackValue;

11攻击方法

public void attack(l

System. out printin武器名:"+name+"t'+"攻击值:"+attackValuel;}
}

上面的两个类中存在大量的重复代码，不能实现代码的复用，同时不易于程序的打展。如果将每个类中相同的代码抽取出来，建立一个公共类，提供给其他类复用，这样会大量减少重复代码，实现代码的复用。以下采用继承要用的方式来实现，具体操作见示例。

(1)创建父类武器类(Weapon)，代码如下，

public class Weapon{

String name;// 武器名
int attackValue;//攻击值

//构造方法
public Weapon(String name, int attackValue) {

System out. printIn("--执行武器父类Weapon的构造方法-- )；

this.name = name;

this . attackValue = attackValue;

//攻击方法
public void attack()｛

System. out printn'"武器名: +name+"\t"+攻击值+attackValuel;｝
｝

(2)创建子类圣剑类(Sword)，代码如下:

public class Sword extends Weaponl{

public Sword(String name, int attackValue){

 (super(name, attackValue);}
}

(3)创建子类长矛类(Spear)，代码如下:

public class Spear extends Weapon{

//构造方法

public Spear(String name,int attackValue)｛
 lsuper(name, attackValue);｝
｝

(4)创建测试类( ExtendsTest)，代码如下:

public class ExtendsTest｛

public static void main(Stringl] args)l

Sword word = new Sword(" Ѫ i ",300);word. attack();

Spear spear = new Spear(" K3 ",250);spear.attack();｝
｝

注：代码仅供参考。

总结：上述程序通过继承提高了代码的复用性，成少了演码量。 注用，子类无法继承父类私有成员，而且在实际的开发中，不建议让子类继承父类的属性，因为子类继承父类的属性会打破父类的封装性。

注意：
Java中的继承为单继承，即一个子类只能有一个直接的父类。