以下资料为java培训为大家整理发布：
专家读书笔记，希望能够对大家学习java有所帮助
"每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。"
这句话怎么理解
所有代码都经过测试，测试环境：
java version "1.4.0-rc "
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.0-rc-b91)
Java HotSpot(TM) Client VM (build 1.4.0-rc-b91, mixed m ode)
如大家发现任何错误，或有任何意见请不吝赐教。
缺省构造函数的问题：base类是父类，derived类是子类，首先要说明的是由于先有父类后有子类，所以生成子类之前要首先有父类。
class是由class的构造函数constructor产生的，每一个class都有构造函数，如果你在编写自己的class时没有编写任何构造函数，那么编译器为你自动产生一个缺省default构造函数。这个default构造函数实质是空的，其中不包含任何代码。但是一牵扯到继承，它的问题就出现了。
如果父类base class只有缺省构造函数，也就是编译器自动为你产生的。而子类中也只有缺省构造函数，那么不会产生任何问题，因为当你试图产生一个子类的实例时，首先要执行子类的构造函数，但是由于子类继承父类，所以子类的缺省构造函数自动调用父类的缺省构造函数。先产生父类的实例，然后再产生子类的实例。如下：
class base{
}
class derived extends base{
public static void main(String[] args){
derived d=new derived();
}
}
下面我自己显式地加上了缺省构造函数：
class base{
base(){
System.out.println( "base constructor ");
}
}
class derived extends base{
derived(){
System.out.println( "derived constructor ");
}
public static void main(String[] args){
derived d=new derived();
}
}
执行结果如下：说明了先产生base class然后是derived class。base constructor
derived constructor
我要说明的问题出在如果base class有多个constructor
而derived class也有多个constructor,这时子类中的构造函数缺省调用那个父类的构造函数呢？答案是调用父类的缺省构造函数。但是不是编译器自动为你生成的那个缺省构造函数而是你自己显式地写出来的缺省构造函数。
class base{
base(){
System.out.println( "base constructor ");
}
base(int i){
System.out.println( "base constructor int i ");
}
}
class derived extends base{
derived(){
System.out.println( "derived constructor ");
}
derived(int i){
System.out.println( "derived constructor int i ");
}
public static void main(String[] args){
derived d=new derived();
derived t=new derived(9);
}
}
D:"java"thinking"think6> java derived
base constructor
derived constructor
base constructor
derived constructor int i
如果将base 类的构造函数注释掉，则出错。
class base{
// base(){
// System.out.println( "base constructor ");
// }
base(int i){
System.out.println( "base constructor int i ");
}
}
class derived extends base{
derived(){
System.out.println( "derived constructor ");
}
derived(int i){
System.out.println( "derived constructor int i ");
}
public static void main(String[] args){
derived d=new derived();
derived t=new derived(9);
}
D:"java"thinking"think6> javac derived.java
derived.java:10: cannot resolve symbol
symbol : constructor base ()
location: class base
derived(){
^
derived.java:13: cannot resolve symbol
symbol : constructor base ()
location: class base
derived(int i){
2 errors
说明子类中的构造函数找不到显式写出的父类中的缺省构造函数，所以出错。
那么如果你不想子类的构造函数调用你显式写出的父类中的缺省构造函数怎么办呢？
如下例：
class base{
// base(){
// System.out.println( "base constructor ");
// }
base(int i){
System.out.println( "base constructor int i ");
}
class derived extends base{
derived(){
super(8);
System.out.println( "derived constructor ");
}
derived(int i){
super(i);
System.out.println( "derived constructor int i ");
}
public static void main(String[] args){
derived d=new derived();
derived t=new derived(9);
}
}
D:"java"thinking"think6> java derived
base constructor int i
derived constructor
base constructor int i
derived constructor int i
super(i)表示父类的构造函数base(i)请大家注意一个是super(i)一个是super(8)。大家想想是为什么？？
结论：子类如果有多个构造函数的时候，父类要么没有构造函数，让编译器自动产生，那么在执行子类构造函数之前先执行编译器自动产生的父类的缺省构造函数；要么至少要有一个显式的缺省构造函数可以让子类的构造函数调用。
《面向对象程序设计》实验报告 实验六、类的继承 课程代码：1H10500学分：6 实验类型：实践型实验学时：4个学时 实验时间：2017.11.23 实验地点：5407 班级：计算机164 专业：计算机科学与技术专业学号：2016011147 姓名：林文辉 一、实验目的 （1）学习JAVA继承的思想 （2）了解JAVA语言继承的实现 二、实验内容及步骤 内容：在圆柱体类Cylinder里，用一个构造方法调用另一个构造方法 步骤：方案的设计与分析（类结构图。。。。。。） （1）找出对象的共同属性和行为 （2）设计代表共同状态与行为的类 （3）决定子类是否需要让某项行为有特定的不同的运行方式 （4）寻找更多抽象化的机会 （5）完成类的继承层次 三、实验过程及结果 实验1代码： abstract class Graphics { abstract void parameter(); abstract void area(); } class Rectangle extends Graphics{ double h,w; Rectangle(double u,double v){h=u;w=v;} void parameter() { S ystem.out.println("矩形高度为:"+h+",矩形宽度为:"+w); } void area() { S ystem.out.println("矩形面积为："+(h*w)); } }
class Circle extends Graphics{ double r; String c; Circle(double u,String v){r=u;c=v;} void parameter() { System.out.println("圆半径为:"+r+",圆颜色为:"+c); } void area() { System.out.println("圆面积为:"+(Math.PI*r*r)); } } class ExamAbs{ public static void main(String args[]) { Rectangle rec=new Rectangle(2.0, 3.0); Circle cir=new Circle(4.0, "Red"); Graphics[]g= {rec,cir}; for(int i=0;i 1,定义一个接口Assaultable(可攻击的)，该接口有一个抽象方法attack()。 2,定义一个接口Mobile（可移动的）,该接口有一个抽象方法move()。 3,定义一个抽象类Weapon,实现Assaultable接口和Mobile接口，但并没有给出具体的 实现方法。 4,定义3个类：Tank,Flighter,WarShip都继承自Weapon,分别用不同的方式实现Weapon 类中的抽象方法。 5,写一个类Army,代表一支军队，这个类有一个属性是Weapon数组w（用来存储该军队所拥有的所有武器）；该类还提供一个构造方法，在构造方法里通过传一个int类型的参数来限定该类所能拥有的最大武器数量,并用这一大小来初始化数组w。该类还提供一个方法addWeapon(Weapon wa),表示把参数wa所代表的武器加入到数组w中。在这个类中还定义两个方法attackAll()和moveAll()，让w数组中的所有武器攻击和移动。 6，写一个主方法去测试以上程序。 interface Assaultable{//可攻击的 void attack(); } interface Mobile{//可移动的 void move(); } abstractclass Weapon implements Assaultable,Mobile { publicvoid attack(){} publicvoid move(){} } class Tank extends Weapon{ publicvoid attack(){ System.out.println("坦克攻击！！！"); } publicvoid move(){ System.out.println("坦克移动！！！"); } } class Flighter extends Weapon{ publicvoid attack(){ System.out.println("战斗机攻击！！！"); } publicvoid move(){ System.out.println("战斗机移动！！！"); 实验三类的继承 实验目的：掌握类的继承、抽象类的定义和使用、对象的向上转型。实验内容：已知若干图形，求以该图形为底的锥体的体积。 实验要求：用面向抽象的思想实现 实验步骤： 1、程序总体框架 2、在shape包中创建抽象类Shape，代码如下： 3、在centrun包中创建一个类Centrun,代码如下： Centrun这个类为核心类，在之后的代码编写中可以不做更改，getVolume函数用来求椎体的体积，即利用抽象类getArea进行适应性计算。 4、创建一个包myshape，在其中先创建一个Circle类，代码如下： Circle是对抽象类shape的继承（记得导入shape包），在Circle类中，利用对getArea 函数代码的重写操作，具体实现了求圆的面积这一操作。【此处的具体实现应该放入该图形的具体面积求法。】 5、创建一个包Test，对以上三个包中的代码进行具体实现，代码如下： 导入myshape包，在main函数中通过向上转型，实例化shape包中的抽象类Shape，然后调用函数输出圆锥的体积。 6、在求出实验结果1，即调试好shape、myshape、centrun这三个包后，不再更改shape、centrun包，而是在myshape包下新建所需的类，如本次实验所需的三角形、矩形； 7、在myshape包下创建一个类Rectangular，代码如下： 8、在myshape包下创建一个类Triangle，需注意的是，求三角形的面积需要判断三角形的三边能否构成三角形（不能构成时返回0），代码如下： 实验结果： 1、Test测试包最终代码： JAVA中继承的总结 一、继承概念： 把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系， 这多个类就具备了这些内容。这个关系叫继承。 二、何时实现继承 A:继承体现的是：is a的关系。 B:采用假设法 三、怎么实现继承 A:用关键字extends表示 B:格式： class 子类名 extends 父类名 {} C:子类 public class 子类 extends 父类 { //增加自己属性 //重写父类的属性 //增加自己的方法 //重写父类的方法 } 四、继承的好处： A:提高了代码的复用性 B:提高了代码的维护性 C:让类与类产生了一个关系，是多态的前提 继承的弊端： A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。 原则：低耦合，高内聚。 耦合：类与类的关系 内聚：自己完成某件事情的能力 B:打破了封装性 五、Java中继承的特点 A:Java中类只支持单继承，只能一个直接父类，Object 根类 B:Java中可以多层(重)继承(继承体系) 六、继承的注意事项： A:子类能继承父类的私有成员,但不是都能访问 B:子类不能继承父类的构造方法，但是可以通过super去访问 C:不要为了部分功能而去继承 七、继承中static用法 A:static:子类可以继承父类的静态方法,但不能重写 B:static 的属性和方法都是不能覆盖的，因为static修饰的部分都是与对象无关的，只与类有关 八、Java继承中的成员关系 A:成员变量 a:子类的成员变量名称和父类中的成员变量名称不一样，这个太简单 b:子类的成员变量名称和父类中的成员变量名称一样，这个怎么访问呢? class shap2D { static double getArea; //面积 static double getPerimeter; //周长 } class circle extends shap2D { double r; double getRadius(){return r=2;} double getArea() {return Math.PI*r*r;} double getPerimeter() {return 2*Math.PI*r;} public String toString() { String s; return s="周长："+getPerimeter()+"面积:"+getArea(); } } class Triangle extends circle { double a,b,c; Triangle (double x,double y,double z) {a=x; b=y;c=z;} void setA(double x){a=x;} double getA(){return a;} public double getPerimeter() {return a+b+c;} public double getArea() { double s=(a+b+c)/2; return Math.sqrt(s*(s-a)*(s-b)*(s-c)); } public boolean isTriangle() { boolean flag=false; if(a>0&&b>0&&c>0&&a+b>c&&a+c>b&&c+b>a) flag=true; return flag; } } class rectangle extends circle { double a,b; 一.extends和super的使用和方法的重写 1.定义一个人的类（属性有名字，年龄。写一个能输出各个属性值 的方法showInfo（）），定义一个学生类（属性有性别），学生继承人类 要求：（1）父类的属性赋值用构造方法来实现（分别用有参数构造方法和无参数构造方法实现） （2）子类的属性也用构造方法来赋值。 （3）在子类中重写父类的showInfo（）方法 （4）声明学生类的对象，调用学生的显示信息的方法。 2 定义Animal父类，含有属性name，sex，age，方法sleep，run，编写一个子类Person，继承Animal类，然后调用父类的属性和方法二． 1、试编写三个具有继承关系的类，A、B、C（B继承A，C继承B）。 要求A中包含方法a1()、a2()，B类中的方法b1()访问了a1() 和a2()，C类中的方法c1()访问了a1()、a2()、b1()。 提示：（a1(),a2(),b1(),c1()这些方法体除了实现题目要求之外，其余内容可以任意编写。） 2、请编码实现动物世界的继承关系： 动物（Animal）具有行为：吃（eat）、睡觉（sleep） 动物包括：兔子（Rabbit），老虎（Tiger） 这些动物吃的行为各不相同（兔子吃草，老虎吃肉）；但睡 觉的行为是一致的。 请通过继承实现以上需求，并编写测试类AnimalTest进行测试。3、父类Person 包含like（）方法子类Son 重写父类方法并打印输出 4、(选做)父类Employee 属性：name、sex ，带一个构造方法Employee(String n, char s) 子类Worker继承自Employee 属性：char category;法（）可以调用父类 的所有非私有方法 B) super（）可以调用父类的所有非私有构造函数 C) super.属性可以调用父类的所有非私有属性 D) this和super关键字可以出现在同一个构造函数中 8．以下关于final关键字说法错误的是（A,C）（两项） A) final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性 B) final修饰的类肯定不能被继承 C) final修饰的方法不能被重载 D) final修饰的变量不允许被再次赋值 9．访问修饰符作用范围由大到小是（D） A) private-default-protected-public B) public-default-protected-private C) private-protected-default-public D) public-protected-default-private 10．以下（D）不是Object类的方法 A) clone（） B) finalize（） C) toString（） D) hasNext（） 11．多态的表现形式有（A） A) 重写 B) 抽象 C) 继承 D) 封装 12．以下对重载描述错误的是（B） Java中类的继承 1、方法重载 重载方法必须满足以下条件: ＃方法名相问. ＃方法的参数类型、个数、顺序至少有一项不相同。 ＃方法的返回类型可以不相同。 ＃方法的修饰符可以不相同. 方法覆盖 (1)子类方法的名称、参数签名和返回类型必须与父类方法的名称、参数签名和返回类型一致. (2)子类方法不能缩小父类方法的访问权限. (3)子类方法不能抛出比父类方法史多的异常， (4)方法覆盖只存在于子类和父类(包括直接父类和间接父类)之间.在同一个 类中方法只能被重载，不能被扭盖。 (5)父类的静态方法不能被子类覆盖为非静态方法。 (6)子类可以定义与父类的静态方法同名的静态方法，以便在子类中隐藏父类的静态方法.在编译时，子类定义的静态方法也必须满足与方法覆盖类似的约束。 (7)父类的非静态方法不能被了类覆盖为静态方法。 (8)父类的私有方法不能被子类覆盖。 (9)父类的抽象方法可以被子类通过两种途径覆盖:一是子类实现父类的抽象方法:二是子类重新声明父类的抽象方法。 (10)父类的非抽象方法可以被覆盖为抽象方法. 方法覆盖与方法重载的异同 方法覆盖和方法重载具有以下相同点: ＃都要求方法同名. ＃都可以用于抽象方法和非抽象方法之间. 方法筱盖和方法重载具有以下不同点: ＃.方法覆盖要求参数签名必须一致.而方法重载要求参数签名必须不一致. ＃.方法覆盖要求返回类型必须一致，而方法重载对此不做限制. ＃.方法覆盖只能用于子类覆盖父类的方法，方法重载用于同一个类的所有方d (包括从父类中继承而来的方法)。 ＃.方法覆盖对方法的访问权限和抛出的异常有特殊的要求，而方法重载在这力面没有任何限制。 ＃.父类的一个方法只能被子类覆盖一次，而一个方法在所在的类中可以被重载多次。 super关键字 super和this关键字都可以用来履盖Java语言的默认作用域.使被屏蔽的方法或变 盆变为可见。在以下场合会出现方法或变量被屏蔽的现象. .场合一:在一个方法内.当局部变量和类的成员变量同名，或者局部变量和父类的成员变量同名时，按照变量的作用域规则，只有局部变量在方法内可 见。 .场合二:当子类的某个方法覆盖了父类的一个方法。在子类的范围内，父类 的方法不可见. .场合三:当子类中定义了和父类同名的成员变量时，在子类的范围内，父类 的成员变量不可见。 在程序中，在以下情况下会使用super关键字: ＃在类的构造方法中，通过super语句调用这个类的父类的构造方法。 ＃在子类中访问父类的被屏蔽的方法和属性。 多态性 它是指当系统A访问系统B的服务时，系统B可以通过多种实现方式来提供服务， 而这一切对系统A是透明的. 多态的各种特性 (1)对于一个引用类型的变量，Java编译器按照它声明的类型来处理. (2)对于一个引用类型的变盆.运行时Java虚拟机按照它实际引用的对象来处理.例如以下代码虽然编译可以通过，但运行时会抛出ClassCastException运行时异常. Sub sub=new Sub(); 类的继承习题 一、选择题 1. Java语言的类间的继承关系是( B )。 A) 多重的B) 单重的C) 线程的D) 不能继承 2. 以下关于Java语言继承的说法正确的是( C )。 A)Java中的类可以有多个直接父类B)抽象类不能有子类 C)Java中的接口支持多继承D)最终类可以作为其它类的父类 3. 现有两个类A、B，以下描述中表示B继承自A的是(D)。 A) class A extends B B) class B implements A C) class A implements B D) class B extends A 4. A） 5. A） 6. Java 7. A)Java C)Java 8. A) class C) class 9. 现有类 A) class C) class 10. A） 11. A） 12. A） 13. java A） 14. 饰符是（ A） 15. A） 16. A）public B) protected C) private D) final 17. 下列选项中，表示终极方法的修饰符是：（B） A）interface B) final C) abstract D) implements 18. 下列选项中，定义接口MyInterface的语句正确的是：（A） A）interface MyInterface{ } B) implements MyInterface { } C) class MyInterface{ } D) implements interface My{ } 19. 如果子类中的方法mymethod()覆盖了父类中的方法mymethod()，假设父类方法头部定义如下：void mymethod(int a)，则子类方法的定义不合法的是：（C） A）public void mymethod(int a) B) protected void mymethod(int a) C) private void mymethod(int a) D) void mymethod(int a) 二、填空题 1. 如果子类中的某个变量的变量名与它的父类中的某个变量完全一样，则称子类中的这个变量________了父类 JAVA课程设计——员工工资管理 import java.util.Scanner; class Employee{ private String name; privateint birthmonth; public String getName() { return name; } publicvoid setName(String name) { https://www.doczj.com/doc/f815297147.html, = name; } publicint getBirthmonth() { return birthmonth; } publicvoid setBirthmonth(int birthmonth) { this.birthmonth = birthmonth; } publicdouble getSalary(int thismonth){ if(birthmonth==thismonth){ return 100; } else return 0; } publicvoid print(){ System.out.print("员工信息：\n姓名:"+name+"，出生月份："+birthmonth+"，"); } public Employee(String name,int birthmonth){ setName(name); setBirthmonth(birthmonth); } } //固定工资 class SalariedEmployee extends Employee{ privateint salary; public SalariedEmployee(String name, int birthmonth,int salary) { super(name, birthmonth); this.salary=salary; } publicdouble getSalary(int thismonth) { return salary+super.getSalary(thismonth); } publicint basesalary(){return salary;} } //小时工 class HourlyEmployee extends Employee{ privateint hoursalary; privateint monthhour; privateint salary; public HourlyEmployee(String name, int birthmonth,int hoursalary,int monthhour) { super(name, birthmonth); 上一次跟别人解答，没想到没提交上去，又不想删了，所以做成文档，才入这行朋友可以看下 Question 1. 编码实现动物世界的继承关系： a) 动物（Animal）具有行为：吃（eat）、睡觉（sleep） b) 受保护得物件（接口）具有得行为：beProtected（）; c) 有价值得物件（接口）具有得行为：getMoney（） d) 老虎是动物，同时是有价值且受保护得动物类型。 e) 熊猫是动物，同时是有价值且受保护得动物类型。 f) 这些动物吃的行为各不相同（熊猫吃竹子，老虎吃肉）；但睡觉的行为是一致的；受保护得级别不一致，价值也不一致。 g) 请通过继承，接口实现以上需求，并编写测试类AnimalTest进行测试。 Animail.java父类-动物类 package com; /** * @author Administrator * */ public class Animal { private String name; private String food; //吃的一个行为 public void eat() throws Exception{ System.out.println(https://www.doczj.com/doc/f815297147.html,+"吃"+this.food+"!"); } //睡觉的一个行为 public void sleep(){ System.out.println(https://www.doczj.com/doc/f815297147.html,+"在睡觉!"); } public String getName() { return name; } public void setName(String name) { https://www.doczj.com/doc/f815297147.html, = name; } public String getFood() { return food; } public void setFood(String food) { this.food = food; } } AnimalInterface.Java 接口 package com; public interface AnimalInterface { //默认为public,因为接口要被实现，并被广范使用， //所以最好是public因为如果不是公开的就没有必要做接口了void beProtected(); void getMoney(); } AnimalTest.java 测试类 package com; public class AnimalTest { /** ava中方法的继承，覆盖 (2011-01-17 02:13:42)转载▼ 标签：杂 谈 首先要明确一点，子类在继承父类时，构造函数是不能被继承的。当创建子类的实例时，子类的构造函数要调用父类的构造函数，也就是说父类要先于子类构造。子类的构造函数可以通过super关键字显式调用父类中的构造函数。如果子类中的构造函数没有显式调用父类中的构造函数，编译器就会自动在子类的构造函数中调用父类中参数为空的构造函数。当父类中没有定义任何构造函数时，编译器就会为它指定一个参数为空的默认的构造函数；如果父类中定义了构造函数，那么编译器就不会为它指定一个参数为空的默认构造函数了。因此，如果某个类有可能成为其他类的父类，为了避免发生不必要的编译错误，最好为它编写一个参数为空的构造函数。父类Sup中没有定义构造函数，编译程序将为它指定一个参数为空的默认构造函数。子类Sub 中也没有定义构造函数，编译程序也会为它指定一个参数为空的默认的构造函数，并且会在这个默认的构造函数中调用父类的参数为空的构造函数。 public class Sub extends Sup{ //子类中没有定义构造函数 public static void main(String args[]){ Sub sub=new Sub(); } } class Sup{ //父类中没有定义构造函数 } 父类Sup中没有定义构造函数，编译程序将为它指定一个参数为空的默认构造函数。子类定义了一个带整型参数的构造函数，在这个构造函数中子类没有显式调用父类的构造函数，所以编译器为在它里面调用父类中参数为空的构造函数。 public class Sub extends Sup{ //子类中定义类一个带整型变量参数的构造函数 public Sub(int i){ // } public static void main(String args[]){ Sub sub=new Sub(1); } } class Sup{ //父类中没有定义构造函数 } 父类中定义了一个带整型参数的构造函数，因此编译器不再为它指定参数为空的默认的构造函数。子类中也定义了一个带整型参数的构造函数。编译时，编译器将试图在子类的构造函数中调用父类的参数为空的构造函数，但是父类中没有定义参数为空的构造函数，所以编译程序将会报 实验五:类的继承以及super的使用 一、实验目的 熟练地掌握Java语言的掌握类的继承以及super的使用的编程。通过实验掌握编写程序的思想方法，体会编程的技巧，加深Java语言的应用能力。 二、实验环境 硬件环境：微型计算机。 软件环境：Windows 2000或以上版本，JKD, Jcreator 三、实验内容与要求 用Java语言编程实现以下问题： 1、利用课本类的继承编写程序，定义一个车类Vehicle，代表一类交通工具，在这个类中包含成员变量品牌brand,颜色color，价格price(单位：万元)和一个void SetVehicle()方法，通过这个方法使其成员变量赋值，再定义一个小汽车类Car 去继承车类Vehicle,在这个类中再包含一个成员变量速度speed和一个void SetCar()方法，通过这个方法使其所有的成员变量赋值再定义一个public类，包含main()方法，在这个方法中，用Car这个类创建一个对象，并分配内存空间，用对象去调用SetCar()方法，然后对象去调用各个成员变量并输出其值。 程序： class Vehicle { String brand,color; double price; void SetVehicle(String b,String c,double p) { brand=b; color=c; price=p; } } class car extends Vehicle { double speed; void SetCar(String b,String c,double p,double s) { SetVehicle(b,c,p); speed=s; } } public class che_test { public static void main(String args[]) { car m=new car(); m.SetCar("联想","银白",2.0,100.0); System.out.println("品牌:"+m.brand+" 颜色:"+m.color+" 价格:"+m.price+" JAVA中类的继承的理解 Java类的继承可以是多层的，但不能是多头的。也就是说类只能继承一个类而不能继承多个类。好比一个人只能有一个爹，不能有多个爹，当然爹上面还能有爹。 类实现继承的格式：class子类名extends 父类名 类的继承有三方面的内容，一是父类变量与方法的继承，二是父类变量与方法的覆写或称之为重载，三是super与this的使用区别。 类的继承使用范例： class Person { String name; int age; } class Student extends Person { String school; } Public class TestPersonStudentDemo { public static void main(String[] args) { Student s = new Student();//实例化了Student类s https://www.doczj.com/doc/f815297147.html, = “张三”; //访问Person类中的name属性 s.age = 25; //访问Person类中的age属性 s.school = “北京” ; //访问Student类中的school属性 System.out.println(“姓名：”+https://www.doczj.com/doc/f815297147.html,+”，年龄：”+s.age+”，学校：”+s.school); } } 子类在继承父类中的方法与属性时，首先会执行父类中的构造方法，再执行子类中的构造方法。一般子类中隐含了super()语句（super主要的功能是完成子类调用父类中的内容）。 类的继承使用范例1： class Person { String name; int age; //父类中的构造方法 public Person(String name,int age) { https://www.doczj.com/doc/f815297147.html, = name; this.age = age; } 继承是类与类之间的关系，是一个很简单很直观的概念，与现实世界中的继承（例如儿子继承父亲财产）类似。 继承可以理解为一个类从另一个类获取方法和属性的过程。如果类B继承于类A，那么B就拥有A的方法和属性。 继承使用 extends 关键字。（参考网站：https://www.doczj.com/doc/f815297147.html,/RA5iKhq） 例如我们已经定义了一个类 People： 1class People{ 2 String name; 3int age; 4int height; 5 6void say(){ 7 System.out.println("我的名字是 " + name + "，年龄是 " + age + "，身高是 " + height); 8 } 9 } 如果现在需要定义一个类 Teacher，它也有 name、age、height 属性和 say() 方法，另外还需要增加 school、seniority、subject 属性和 lecturing() 方法，怎么办呢？我们要重新定义一个类吗？ 完全没必要，可以先继承 People 类的成员，再增加自己的成员即可，例如： 1class Teacher extends People{ 2 String school; // 所在学校 3 String subject; // 学科 4int seniority; // 教龄 5 6// 覆盖 People 类中的 say() 方法 7void say(){ 8 System.out.println("我叫" + name + "，在" + school + "教" + subject + "，有" + seniority + "年教龄"); 9 } 10 11void lecturing(){ 12 System.out.println("我已经" + age + "岁了，依然站在讲台上讲课"); 13 } 14 } 第八章类的继承和多态 教学目的： 深刻理解类的继承 教学内容： 1、类的继承和实现 2、构造器的调用 3、防止类的继承 一、类的继承和实现 所谓继承就是在已经存在类的基础上再扩展新的类。已经存在的类我们称父类、超类、基类。新产生的类，我们称子类、派生类。子类拥有父类的所有特性。当然我们也可以在子类中添加新的方法和成员变量，这些新添加的方法和成员变量仅仅属于子类。 在Java中通过关键字“extends”来实现。 比如在学生类中，有一种特殊的学生就是学生干部，他们出来拥有和普通学生一样的方法和属性之外，有的有一个职务描述（Duty）。 我们定义学生管理类ClassManger，它拥有父类的所有的方法和属性。 一般来讲，应该把相对通用的方法都放在父类中，只有更具体和专门的方法放在子类中。 1、对于学生干部而言，我们要添加一个属性就可以了 private String duty=””; 2、但是student里的print()就不能满足我们的ClassMange的要求了。而且student的构造方法也不能直接用来ClassMange上。 那么我们怎么定义ClassMange()和print()呢？如果重新写很麻烦，可不可以在父类方法的基础上修改呢？只要使用关键字super就可以了。 this：一个对象的引用。 super：是用来告诉编译器调用父类的方法的关键字。 代码如下： class school { public static void main(String[] args) { student[] stu=new student[3]; stu[0]=new ClassMange("章三","2009001","班长"); stu[1]=new student("李四","2009002"); stu[2]=new student("王五","2009003"); /* for (int i=0;iJava 接口与类之间继承例题
java 类的继承 实验报告(含代码)
java中继承的相关知识总结
JAVA继承类求几何图形面积周长代码
java练习题-继承
Java中类的继承
JAVA复习习题(继承)
JAVA课程设计——员工工资管理(类的继承)
java 中关于 继承 的一个小例子
java中方法的继承
java程序设计类的继承以及super的 使用
JAVA中类的继承的理解
Java继承的概念与实现
java类的继承和多态
相关主题
文本预览