继承与多态、抽象类与接口
继承与多态
一、什么是类的继承
1.继承的概念
Java的继承是指在一个现有类的基础上去构建一个新类，现有类叫父类，而基于现有类构建出的新类叫子类，子类可以拥有父类中的成员。
2.子类的设计
创建类的语法格式如下：
[修饰符] class <类名> { 各种成员变量的定义; 各种成员方法的定义; }
在Java 中，往往在声明一个类的同时需要继承另一个类，这时就需要使用extends关键字来指明其父类。创建类的完整的语法格式如下：
[修饰符] class <类名> [extends 父类名][implement 接口列表]{ 各种成员变量的定义; 各种成员方法的定义; }
3.继承中的protectd
在上一个模块的学习中，我们知道， 一个类中的成员变量和成员方法的修饰符可以是public、protected、private。 其中，被public修饰的属性可以被子类继承，而被private修饰的则不能被子类继承。那被protected修饰的成员方法和成员变量呢?如果父类和子类在同一个包中，那么protected 等价于public，，如父类和子类不在同一个包中， 那么 protected 等价于private。
4.继承的使用原则
子类可以继承父类中所有可被子类访问的成员变量和成员方法， 但必须遵循以下原则。
(１)子类可以继承父类中被声明为public、protected(父类和子类在同一个包中)的成员变量和成员方法，但是不能继承被private修饰过的成员变量和成员方法。
(２)如果子类声明了一个与父类同名的成员变量， 则子类不能继承父类的成员变量，因为此时，子类中的成员变量隐藏了父类的同名成员变量。
(３)同理，如果子类声明了一个与父类同名的成员方法，则子类不能继承父类的成员方法， 因为此时，子类中的成
员方法隐藏了父类的同名成员方法。
5.super关键字的使用
使用super关键字用来在子类中访问父类中被子类隐藏的成员方法和成员变量。super关键字的用法主要有以下两种：
（1）使用super关键字访问父类的构造方法
子类调用父类的构造方法，其具体语法格式如下：
super [参数列表];
（2）使用super关键字访问父类中与子类同名的成员方法和成员变量
其具体语法格式如下：
super. 成员变量; super. 成员方法[参数列表];
二、final关键字
1.final修饰变量
final修饰的变量(包括成员变量和局部变量)会变成常量，只能赋值一次。
2.final修饰类
被 final修饰的类，不能被继承， 即该类不能有子类。
3.final修饰方法
被final修饰的方法，不能被重写，即该类的子类不能重写该方法。
三、什么是多态
1.多态的概念
所谓多态是指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为，这使同一个属性或方法在父类及其各个子类中具有不同的含义， 面向对象的多态性提高了程序可复用性、 可扩充性和可维护性。
对面向对象来说， 继承是多态得以实现的基础， 而多态的行为主要包括方法的重载和向上转型。
方法的重载: 指在同一个类中，根据参数列表的不同来区分同名的方法。
向上转型: 指在有继承关系的类中，将子类的引用赋给父类对象，即子类的对象是父类类型。
2.构造方法的重裁
在一个类中，可以定义多个构造方法，这些构造方法的方法名虽然相同，但是它们的参数类型或者参数个数是不同的， 在创建对象时，可以根据参数的类型或个数来选择调用相应的构造方法。
3.成员方法的重裁
在一个类中，可以定义多个同名的成员方法， 虽然方法名相同，但是它们的参数类型或者参数个数是不同的，Java 在执行具有重载关系的方法， 可以根据参数的类型或个数来选择调用相应的成员方法。
4.对象的类型转换
所谓对象的类型转换，就是指向上转型或者向下转型。即 将子类的对象当作父类类型使用， 或者将父类的对象当作子类类型使用，它是多态性的另外一种表现形式。
四、设计工资管理系统
1.任务描述
实现一个名为Person的类和它的子类Employee， 再设计Manager类， 它是Employee 的子类， 最后设计一个类Add()用于涨工资， 普通员工一次能涨 10％， 经理能涨20％.
2.任务目标
(１)学会分析“工资管理系统”子任务实现的逻辑思路。
(２)能够独立完成“工资管理系统”程序的源代码编写、 编译及运行。
(３)实理现解思继路承和多态的相关概念及使用。
3.实现思路
(１)首先设计 Person类， 该类中的属性有: 姓名name String(类型)、 地址address(String类型)、 定义该类的构造方法。
(２)然后设计Employee 类， 该类中的属性有: 工号 ID(String类型)、 工资wage(double类型)、 工龄(int 型)、 定义该类的构造方法。
(３)接着设计 Manger类， 该类中的属性有: 级别 level(String类型)、 定义该类的构造方法。
(４)最后代编码写一个测试类，产生一个员工和一个经理， 给该员工和经理涨工资。
4.实现代码
（1）定义Person类
public class Person { private String name=""; private String address=""; //定义构造方法 public Person ( String name, String address) { this. name = name; this. address = address; } }
（2）定义Employee类并继承Person类。
//继承Person类 public class Employee extends Person{ private String ID = ""; private double wage = 0; private int age = 0; public Employee(String name, String address, String ID, double wage, int age){ super(name, address); //调用父类的构造方法 this. ID = ID; this. wage = wage; this. age = age; } public double add (String position){ //判断职位 if(position = = "0" ) wage = wage *1.2; } else{ wage = wage * 1.1; } return wage; } //设置 get/set方法 public double getWage(){ return wage; public void set Wage (double wage){ this. wage = wage; } }
（3）定义Manger并继承Employee 类。
public class Manager extends Employee{ private String level = ""; //1为普通员工,0为经理 public Manager( String name, String address, String ID, double wage, int age, String level) { super( name, address, ID, wage, age); this. level = level; //设置get/set方法 public String getLevel (){ return level; public void setLevel ( String level){ this. level = level; } }
（4）定义测试类Test， 完成相应的操作。
public class Test { public static void main( String[] args){ //新建对象 Manager normal = new Manager( "wsl", "jit" , " 12" , 1000, 2, "1"); Manager manager = new Manager(" ctl" , "jitt" , " 123" , 5000, 10, "0"); //传入职位,Manager类型的对象没有add()方法,所以自动搜寻其父类,调用add()方法 normal. add( normal. getLevel()) ; manager. add (manager. getLevel()); System. out. println ("TT资:" +normal. get Wage()); System. out. println ("经理的T资:" +manager. getWage()); } }
5.运行结果
抽象类与接口
一、什么是抽象类
1.抽象类的定义
在面向对象的概念中，所有的对象都是通过类来描绘的。但是反过来， 并不是所有的类都是用来描绘对象的， 如果一个类中没有包含足够的信息来描绘一个具体的对象， 这样的类就是抽象类。 简单来说，在Java 中， 如果一个类中包含了抽象方法(只包括方法声明， 而不包含方法体)。则该类就必须定义成抽象类，抽象方法的具体实现则由抽象类派生出的各子类来完成。这使程序的功能描述和功能实现得以分离，此外， 由于一个抽象类可派生多个子类。 因此， 抽象类中的一个抽象方法可以在多个子类中有多种实现方式，这也实现了程序的多态性。
（1）抽象类的定义的语法格式
public abstract class 类名 // 声明抽象类 } { // 声明抽象类成员 }
（2）抽象类成员组成
a. 成员变量。
b.成员常量。
c.构造方法，有构造方法，但是不能实例化，构造方法用于子类访问父类数据的初始化。
d.成员方法，可以包含限定子类必须完成某些动作的抽象方法(除非子类也是抽象类。否则抽象方法必须在子类中重写)， 也可以包含提高代码复用性的非抽象方法。
（3）抽象类的特点
a.抽象类和抽象方法必须使用 abstract关键字修饰。
b.抽象类是不能实例化的，也就是说，不能基于抽象类来创建对象，抽象方法不能有方法体。
c.抽象类的子类要么重写抽象类中所有的抽象方法，要么是抽象类。
2.抽象类的使用
抽象类与抽象方法的使用方法，其中，分别定义抽象类 Animal及两个子类，子类分别覆盖抽象类中的Bark( ) 抽象方法，从而使程序能够用一种方法实现不同动物的叫声。
二、什么是接口
1.接口的定义
如果一个抽象类中的所有方法都是抽象的，则可以将这个类用另外一种方式来定义，即接口。 和抽象类的作用类似， 接口也可以把“做什么”和“怎么做”， 即程序的功能和实现分离开来。Java 语言是单一继承语言，即一个类只能直接继承一个父类，这就使 Java的继承结构形成一个树状结构， 这种单一继承关系从某种程度上使Java的继承逻辑变得简单、 清晰。 降低了编程难度，但同时也有了一些局限，可以利用接口弥补这个不足， 即一个子类可以实现多个接口。
（1）抽象类定义的语法结构
[public] interface 接口名 [extend 接口1,接口2......] //声明接口 { //声明接口成员 }
由于接口中的方法都是抽象的，因此不能通过创建实例化对象的方式来调用接口中的方法， 此时， 还需要一个类通过implements关键字来实现接口中的所有方法，接口的实现类声明格式如下：
[修饰符] class<类名> [extends <父类名>] [implement接口名]
（2）接口成员组成
a.成员常量， 接口中只有常量，并且默认为静态。
b.构造方法,，接口中不能有构造方法.
c.成员方法，只能包含限定子类必须完成某些动作的抽象方法。
（3）接口特点
a.接口中只能定义抽象方法，不能定义非抽象方法。
b.类和接口之间不能继承(extends)，只能实现(implements)。
c.接口不能实例化，只能对实现接口的子类进行实例化。
d.类可以不重写接口的所有抽象方法，则该类必须定义为抽象类。
2.接口的一对多实现
由于 Java支持接口的多继承， 因此可以在implements后面列出要实现的多个接口， 这些接口名称之间应以逗号分隔， 例如：
[修饰符] class <类名> [extends <父类名>] [implements <接口１>，<接口2>......]
3.接口的使用
接口的定义和使用很容易， 但要注意一点，由于系统要求继承接口的类中必须实现接口的全部方法， 因此， 一旦修改了接口内容，很可能会导致相关类变成抽象类，而抽象类是不能实例化的。
三、设计学生管理系统
1.任务描述
学生管理系统主要用于学生信息的处理和存储，实现学生信息管理的系统化、 科学化、规范化和自动化，其主要功能是对学生各种信息进行日常管理。 如查询、 修改、 增加、 删除等，本案例较为简单地实现了三个类及一个接口，分别是: 学生类、 教师接口、 教师接口实现类、 运行类。训练学生对继承和多态的理解运用，为以后开发功能更加完善的学生管理系统打下良好的基础。
2.任务目标
进一步掌握继承和多态的实现方式。
3.实现思路
本程序设计一个学生类，包括学生姓名、 电话、 年龄等信息。再设计一个教师接口， 规范教师所能做的操作， 最后设计一个子类来实现教师接口， 完成教师对学生信息的录入和查看。
4.实现代码
（1）定义一个学生类
package studentsystem; public class Stu{ //基本属性 public String name, tel, age; public boolean sex; public static int i=0; //人数总和 private Stu[] s=new Stu[5]; //创建学生表, //返回表 public Stu[] TheStuArrar() { return s;} public Stu(){ } //有参构造方法用来向表添加学生 public Stu( String a, String b, String c, boolean d){ name=a; age=b; tel=c; sex=d; } //相关属性的get/set方法 public String getName(){ return name; } public void setName(String name) { this. name = name; } public String getTel(){ return tel; } public void setTel(String tel){ this, tel = tel; } public String getAge() { return age; } public void setAge (String age){ this. age = age; } public boolean getSex(){ return sex; } public void setSex( boolean sex){ this. sex = sex; } }
（2）定义一个教师接口
package studentsystem; public interface Teacher1{ //教师拥有对表的操作权限 abstract public void jiemian (Stu [] st) ; //初始界面,选择操作 abstract public void set ( Stu [] st); //存储 abstract public void ShowStu(Stu [] st) ; //查看 }
（3）定义一个具体教师类来实现教师接口
package studentsystem; import java. util. Scanner; public class TeacherCan implements Teacher1{ //界面 public void jiemian(Stu[] st) //参数是执行的对象 } System. out. println(" --------学生管理系统-------"); int a; Scanner sc = new Scanner( System. in); //一直执行操作，直到某些情况满足就break退出循环 for(;;){ System. out. println (" 1. 查看生信息"); System. out. println("2. 存储生信息"); System. out. println("按数字0退出系统"); a = sc. nextlnt(); if(a= =0) break; //用switch判断用户的选择，非法输入无效 switch (a){ case 1:ShowStu(st); break; case 2:set(st); break; default: System. out. println("输入无效! In"); } } } //查看 public void ShowStu(Stu[] st){ System. out. println("序号"+" \t 姓名:"+" \t年龄:"+ "\t性别:"+" \t电话:"); //过滤掉空的元素，这里不用成员变量i,所以不担心变量名重复 //doo用来展示序号,i遍历st数组 for( int i=0, doo = 0; i<st. length; i++, doo++){ if(st[i] = =null) | doo--; continue; } System. out. println( (doo+1)+" \t "+st[i]. getName() +" \t "+st[i]. getAge() +" \t" +st[i]. getSex()+" \t "+st[i]. getTel() +" \t "); } } //存储 public void set(Stu[] st) { Scanner s= new Scanner( System. in); String a,b,c,f; boolean d; int e; //往数组的空元素插入数据 //条件设置成<=，是为了在内存用完后继续增加时提示空间不足 for( int it=0; it<= st. length; it++) { //控制语句，当内存10个用完了时还调用该方法增加人员，提示并退出 if(Stu. i>=st. length){ System. out. println("e不足,对象内存(" +st. length+" )已用完! \n"); break; } if(st[it] = = null) | System. out. println("第"+(Stu. i+1) +"个学生的信息:"); System. out. print("名:"); a=s. nextLine(); System. out. println (":"); b=s. nextLine(); System. out. println("电话:"); c=s. nextLine(); System. out. println(": (true, false女生)"); d=s. nextBoolean(); //往空元素插入新学生 st[ it] = new Stu(a,b,c,d); //人数标记+1 Stu. i++; System. out. println("写入成功!按数字0退出,按1继续"); e=s. nextInt(); if(e==0) break; else s. nextLine(); //这里会产生回车残留,需要用nextLine()吸收 } } } }
（4）定义类Run，完成相应的操作
public class Run{ public static void main ( String [] args){ teacherCan t1 = new teacherCan() ; //new老师 stu st= new stu() ; //new学生表 t1. jiemian(st. TheStuArrar()) ; //老师进行操作 } }
5.运行结果
浙公网安备 33010602011771号