packagecom.edu_01;
public class Student {
//私有化成员变量
private String name;
private int age;
//set/get方法
public voidsetName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
//有参数+无参数的构造
public Student(){}
public Student(String name,int age){
this.name = name;
this.age = age;
}
//吃饭和睡觉的方法
public void eat(){
System.out.println("学生喜欢吃米饭");
}
public void sleep(){
System.out.println("学生喜欢趴着睡");
}
}
packagecom.edu_01;
public class Teacher {
//私有化成员变量
private String name;
private int age;
//set/get方法
public voidsetName(String name){
this.name = name;
}
public StringgetName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
//有参数+无参数的构造
publicTeacher(){}
publicTeacher(String name,int age){
this.name = name;
this.age = age;
}
//吃饭和睡觉的方法
public void eat(){
System.out.println("老师喜欢吃饺子");
}
public void sleep(){
System.out.println("老师喜欢站着睡");
}
}
packagecom.edu_02;
继承的好处：
A:提高了代码的复用性
多个类相同的成员可以放到同一个类中
B:提高了代码的维护性
如果功能的代码需要修改，修改一处即可
C:让类与类之间产生了关系，是多态的前提
方法重写(子类的方法名，参数和父类完全一样，将父类方法覆盖)：
1.必须存在继承关系
2.父类的方法满足不了你的需求，此时你就需要重写父类的方法，实现自己想要实现的功能*
public class Person {
//私有化成员变量
private String name;
private int age;
//set/get方法
public voidsetName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
//有参数和无参数的构造
public Person(){}
public Person(String name,int age){
this.name = name;
this.age = age;
}
//吃饭和睡觉的方法
public void eat(){
System.out.println("民以食为天");
}
public void sleep(){
System.out.println("睡觉也是个大事情");
}
}
packagecom.edu_02;
public class Student extends Person{
//如果父类的方法不满足子类的需求，子类可以写一个一摸一样的方法在自己的类体中，这样就实现了方法重写
public void eat(){
System.out.println("学生喜欢吃米饭");
}
}
packagecom.edu_02;
public class Teacher extends Person{
//老师喜欢躺着睡，需要重写父类的sleep()方法
public void sleep(){
System.out.println("老师喜欢躺着睡");
}
}
packagecom.edu_02;
public class Test {
public static voidmain(String[] args) {
//创建一个学生对象
Student s = newStudent();
s.eat();//子类继承了父类的eat()方法和sleep()方法
s.sleep();
System.out.println("------------------");
//创建一个老师对象
Teacher t = newTeacher();
t.eat();
t.sleep();
}
}
packagecom.edu_03;
* 1.3
继承的特点：（代码演示）
A:Java只支持单继承，不支持多继承。
B:Java支持多层(重)继承(继承体系)。
什么时候使用继承呢?
继承中类之间体现的是：”is a”的关系。
采用假设法。
举例：水果，香蕉
举例：水杯，水果 (不能采用继承。)
举例：动物，狗
java中有一个基类，这个类是我们java中所有类的父类，所有类都直接或者间接的继承自在这个类
，这个是Object类
classGrandFather{}
class Father extendsGrandFather{}//java不支持多继承，但支持多重继承
class Mother{}
//创建一个儿子类
//class Son extendsFather,Mother{}//java中只支持单继承
class Son extends Father{}
public classExtendsDemo {
}
packagecom.edu_03;
需求：
请在show方法中输出40，30，20，10
class Fu {
public int num = 10;
public int num4 = 50;
}
class Zi extends Fu {
public int num2 = 20;
public int num = 30;
public void show() {
int num = 40;
//请问这里面代码怎么写？？？
System.out.println(num);//输出40
System.out.println(this.num);//this代表的是本类的一个对象，谁调用我，我指代谁
System.out.println(num2);
System.out.println(super.num);//super可以理解为父类的一个对象
System.out.println(num4);
}
}
public classExtendsDemo2 {
public static voidmain(String[] args) {
//创建Zi类的对象
Zi z = new Zi();
z.show();
}
}
packagecom.edu_03;
/**
* 怎么去访问父亲的成员呢?
java就提供了一个关键字：super
super:
super代表父类存储空间的标识(可以理解为父类对象)
this和super的使用区别?
A:成员变量
this.成员变量本类的成员变量
super.成员变量父类的成员变量
B:成员方法
this.成员方法() 本类的成员方法
super.成员方法()父类的成员方法
*/
class Fu1{
//创建一个成员变量
public int num = 20;
//成员方法
public void show(){
System.out.println("这个是父类的show方法");
}
}
class Zi1 extends Fu1{
//创建两个成员变量
public int num = 10;
public int num2 = 20;
//创建两个成员方法
public void method(){
System.out.println("zi的method()");
}
public voidfunction(){
//字啊这里调用method()
//this.method();//调用本类的method方法
//super.show();
System.out.println("zi的function()");
}
public void show(){
int num = 40;
System.out.println(num);
System.out.println(num2);
System.out.println(this.num);
System.out.println(super.num);
}
}
public classExtendsDemo3 {
public static voidmain(String[] args) {
//创建一个zi1的对象
Zi1 z = new Zi1();
z.function();
z.show();
}
}
packagecom.edu_03;
/**
* 1.5
继承间的成员方法关系：
A:方法名不同，非常简单
B:方法名相同
首先在子类中找
然后在父类中找
如果还是没有就报错。(不考虑父亲的父亲…)
*/class Fu2{
public void show(){
System.out.println("fu2中的show方法");
}
public void method(){
System.out.println("fu2的method方法");
}
private void function(){
System.out.println("fu2的function方法");
}
}
class Zi2 extends Fu2{
public void show(){
System.out.println("zi2中的show方法");
}
public void sleep(){
System.out.println("睡觉的方法");
}
}
public classExtendsDemo4 {
public static voidmain(String[] args) {
//创建zi2的对象
Zi2 z = new Zi2();
z.sleep();
z.show();
z.method();
//z.fuction();//子类无法继承父类中私有的方法
}
}
packagecom.edu_04;
public class Animal {
//成员变量
private String type;
private String name;
private int age;
//set/get方法
public voidsetType(String type){
this.type = type;
}
public String getType(){
return type;
}
public voidsetName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
//有参数和无参数构造
public Animal(){
System.out.println("Animal的无参数的构造");
}
public Animal(Stringtype,String name,int age){
System.out.println("Animal的有参数的构造");
this.type = type;
this.name = name;
this.age = age;
}
public void eat(){
System.out.println("动物喜欢吃粮食");
}
}
packagecom.edu_04;
public class Dog extends Animal{
//给dog创建有参数和无参数的构造方法
//在我们类中的每一个构造方法中的第一行，都会默认存在一个super(),这个就是用来访问父类的构造用的
public Dog(){
//super();//注意：这个super()必须输现在第一行，如果出现在下面，就会造成父类数据的重复初始化
//super(type, name, age);//此时当父类中只有有参构造，没有无参构造的时候，无法在此处访问父类的有参构造初始化父类数据
System.out.println("dog的无参数的构造");
}
public Dog(String type,Stringname,int age){
//super();
super(type,name, age);
System.out.println("dog类的有参数的构造");
setAge(age);
setName(name);
setType(type);
}
}
packagecom.edu_04;
/**
* 1.7
继承间构造方法的关系：
子类中所有的构造方法默认都会访问父类中空参数的构造方法(super())
为什么呢?
因为子类会继承父类中的数据，可能还会使用父类的数据。
所以，子类初始化之前，一定要先完成父类数据的初始化。
每个子类的构造方法的第一行，有一条默认的语句:
super();
注意：仅仅是完成数据的初始化，创建对象目前必须用new申请空间。
假如父类没有无参构造方法,该怎么办呢?
A:调用父类的其他构造方法。带参构造。
怎么访问呢?
super(...)
注意：
super(…)或者this(….)必须出现在第一条语句上。
因为如果可以放后面的话，就会对父类的数据进程多次初始化。所以，只能放在第一条语句上。
建议：
永远给出无参构造方法。
*/
public class Test {
public static voidmain(String[] args) {
//创建一个dog对象
/* Dog d = new Dog();
d.setAge(10);
d.setName("大黄狗");
d.setType("金毛");
d.eat();
System.out.println(d.getAge()+" "+d.getName()+" "+d.getType());*/
System.out.println("------------------------");
//Dog d2 = new Dog();//子类是无法继承父类的构造方法的
System.out.println("---------------------");
//调用dog类的无参数的构造方法
//Dog d = new Dog();
//在我们创建子类对象的时候，会默认访问父类的构造方法，此时这个构造方法并不是创建一个
//父类的对象，仅仅是用来初始化父类的数据用的，为什么我们在这里需要初始化父类的数据呢
//因为我们子类在后面有可能会使用我这个父类中的数据
//调用dog类的有参数的构造
Dog d = new Dog("藏獒", "bob", 2);
}
}
packagecom.edu_05;
public class Animal {
private String type;
private int age;
private String name;
public Animal(){}
public Animal(Stringname,String type,int age){
this.name = name;
this.type = type;
this.age = age;
}
public voidsetType(String type){
this.type = type;
}
public String getType(){
return type;
}
public voidsetName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age =age;
}
public int getAge(){
return age;
}
//吃饭的方法
public void eat(){
System.out.println("动物喜欢吃粮食");
}
}
packagecom.edu_05;
public class Cat extends Animal{
public Cat(){}
public Cat(Stringname,String type,int age){
setAge(age);
setName(name);
setType(type);
}
//猫喜欢吃鱼
/* public void eat(){
System.out.println("猫咪喜欢吃鱼");
}
*/
}
packagecom.edu_05;
public class Dog extends Animal{
//有参数和无参数的构造方法
public Dog(){}
public Dog(Stringname,String type,int age){
setAge(age);
setName(name);
setType(type);
}
//狗喜欢吃肉
public void eat(){
System.out.println("狗喜欢吃肉");
}
}
packagecom.edu_05;
public class Test {
public static voidmain(String[] args) {
//创建对象
Dog d = new Dog();
d.eat();
System.out.println("------------");
Cat c = new Cat("bob", "波斯猫", 2);
c.eat();
System.out.println(c.getAge()+" "+c.getName()+" "+c.getType());
}
}
packagecom.edu_06;
public class Apple extends Fruit{
//有参和无参构造
public Apple(){}
public Apple(Stringtype,String color){
setColor(color);
setType(type);
}
}
packagecom.edu_06;
public class Fruit {
private String type;
private String color;
public Fruit(){}
public Fruit(Stringtype,String color){}
public voidsetType(String type){
this.type = type;
}
public String getType(){
return type;
}
public voidsetColor(String color){
this.color = color;
}
public String getColor(){
return color;
}
public void show(){
System.out.println(type+" "+color+" ");
}
}
packagecom.edu_06;
public class Test {
public static voidmain(String[] args) {
//创建Apple对象
Apple a = new Apple();
a.show();
System.out.println("-------------");
Apple a2 = new Apple("红富士", "红色");
a2.show();
System.out.println(a2.getColor()+" "+a2.getType());
}
}
packagecom.edu_07;
* 二：final关键字
在实际开发的时候，有些方法的内容一旦写定后，就不允许被改动。
即时是子类，也不允许。那么该怎么解决这个问题呢?
java为了解决这样的问题就提供了一个关键字：final
final:
最终的意思。它可以修饰类,方法,变量。
特点：
修饰方法，方法不能被重写。
修饰类，类不能被继承。
修饰变量，变量的值不能再改动。其实这个时候变量已经变成了常量。
常量：
A:字面值常量
'a',12,"hello"
B:自定义常量
就是把变量用final修饰。
定义一个常量。
final 数据类型变量名;
class Fu{//一个类如果被final修饰过后，就不能被继承
//写一个被final修饰的方法
public final void eat(){
System.out.println("fu的eat()");
}
}
class Zi extends Fu{
//尝试重写父类中的eat(),子类复发重写父类中被final修饰过的方法
/*public void eat(){
}*/
final int NUM = 20;
//自定义一个常量，这个常量有多个单词组成
final int MAX_AGE = 30;
final String URL = "WWW.BAIDU.COM";
}
public class FinalDemo{
public static voidmain(String[] args) {
//创建Zi的对象，访问他的被final修饰过的成员变量num
Zi z = new Zi();
//尝试改变被final修饰过的成员变量num
//z.num = 30;//被final修饰过的变量不能被更改，此时他已经成了常量
System.out.println(z.NUM);
}
}
packagecom.edu_08;
* 三：多态
3.1
多态：同一个对象,在不同时刻表现出来的不同状态。
举例：
A:猫
猫是猫
猫是动物
B:水
水(液态)
冰(固态)
水蒸气(气态)
多态的前提：
A:有继承关系
B:有方法重写（不是必要条件，但是只有有了方法重写多态才有意义）
C:有父类引用指向子类对象
Fu f = new Fu();
左边：Fu类型的引用
右边：Fu类型的对象
Zi z = new Zi();
Fu f = new Zi();
3.2
成员访问特点
A:成员变量
编译看左边,运行看左边
B:构造方法
子类构造默认访问父类的无参构造
C:成员方法（重点理解）
编译看左边,运行看右边
为什么变量和方法不一样呢?
方法重写。
D:静态成员方法
编译看左边,运行看左边
因为静态的内容是和类相关的，与对象无关。
class Fu{
//创建一个成员变量
int num = 20;
public void show(){
System.out.println("fu的show（）");
}
public static void method(){
System.out.println("fu的method（）");
}
}
class Zi extends Fu{//1.存在继承关系
int num = 30;
public void show(){//2.存在方法重写
System.out.println("zi的show");
}
public static void method(){
System.out.println("zi的method（）");
}
}
public classDuoTaiDemo {
public static voidmain(String[] args) {
//3.父类引用指向子类对象
Fu f = new Zi();
System.out.println(f.num);
//多态的情况下：成员变量的访问特点是，编译看左边，运行看左边
System.out.println("---------------------------");
f.show();
//多态的情况下：成员方法的访问特点：编译看左边，运行看右边
System.out.println("---------------------------");
f.method();
//多态情况下静态成员方法的访问特点：编译看左边，运行看左边
}
}
packagecom.edu_09;
public class Animal {
private String type;
private int age;
private String name;
public Animal(){}
public Animal(Stringname,String type,int age){
this.name = name;
this.type = type;
this.age = age;
}
public voidsetName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public intgetAage(){
return age;
}
public voidsetType(String type){
this.type = type;
}
public String getType(){
return type;
}
//吃的方法
public void eat(){
System.out.println("动物喜欢吃饭");
}
}
packagecom.edu_09;
public class Cat extends Animal{
public Cat(){}
public Cat(Stringname,String type,int age){
setAge(age);
setName(name);
setType(type);
}
//猫喜欢池鱼
public void eat(){
System.out.println("猫喜欢吃鱼");
}
//猫有一个特有的功能，猫会捉老鼠
public voidcatchMouce(){
System.out.println("猫有一个捉老鼠的特有技能");
}
}
packagecom.edu_09;
public class Dog extends Animal{
public Dog(){}
public Dog(String name,intage,String type){
setAge(age);
setName(name);
setType(type);
}
//狗有一个特有技能会看门
public voidlookDoor(){
System.out.println("狗会看门");
}
}
packagecom.edu_09;
* 练习：（猫狗案例演示）
如何使用子类特有功能
A:创建子类对象
B:把父类引用转为子类对象
向上转型
从子到父
父类引用指向子类对象
向下转型
从父到子
父类引用转为子类对象
*/
public class Test {
public static voidmain(String[] args) {
//使用多态的方式创建一个Cat对象
Animal a = new Cat();
a.eat();
//a.catchMouce();
//需求：就像在这里调用猫中特有功能，捉老鼠
//方式1：创建Cat对象，使用Cat类型去接受
Cat c = new Cat();
c.catchMouce();
System.out.println("------------");
//方式2:向下转型，将父类引用转换成子类对象
Cat c2 = (Cat)a;
c2.catchMouce();
System.out.println("--------------");
//将a这个引用转换成Dog对象？？？
//Dog d = (Dog)a;
//java.lang.ClassCastException:类型转换异常
//d.eat();
//d.lookDoor();
System.out.println("----------------");
Animal a2 = new Dog();
a2.eat();
//a2.lookDoor();
Dog d = (Dog)a2;
d.lookDoor();
}
}
packagecom.edu_10;
* 4.1
抽象类特点:
A:抽象类和抽象方法必须用abstract关键字修饰
B:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
C:抽象类不能实例化
那么，如果实例化并使用呢?
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
D:抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法
抽象类的作用：
强制要求子类必须要重写某些方法。
*
*/
abstract class Animal{
//抽象类中不一定有抽象方法
public void sleep(){
System.out.println("动物都喜欢睡大觉");
}
//定义一个抽象方法,1.使用abstract进行修饰 2，抽象方法没有方法体，因为抽象根本就不是一个具体的方法
//3.如果一个类中有抽象方法，这个类一定是抽象类 4.抽象方法没有具体的实现，需要让他的具体子类做具体的实现
public abstract void eat();
}
class Dog extends Animal{
public void eat() {
System.out.println("狗喜欢吃肉");
}
}
class Cat extends Animal{
public void eat() {
System.out.println("猫喜欢吃鱼");
}
}
//定义一个抽象类继承Animal这个类,如果一个抽象类继承另一个抽象类，不需要重写父类中的抽象方法
//abstract classPerson extends Animal{}
public classAbstractDemo {
public static voidmain(String[] args) {
//创建狗的对象
Dog d = new Dog();
d.eat();
System.out.println("----------");
//使用多态的方式创建对象，并调用eat（）方法
//此时使用的多态的方式是：抽象类多态
/**
* 多态的分类：
*1.普通类多态
*2.抽象类多态
* 前两种全部是父类引用指向子类对象
*3.接口多态
* 父接口引用指向接口实现类对象
*/
Animal a = new Dog();
a.eat();
}
}
packagecom.edu_10;
* 4.2
抽象类--特点--成员特点--案例
类的组成：
成员变量：
构造方法：
成员方法：
抽象类的成员：
成员变量：可以是变量，也可以是常量。
构造方法：有构造方法
不能实例化,构造方法有什么用呢?
用于子类访问父类数据的初始化。
成员方法：既可以是抽象的，也可以是非抽象的。
abstract class Animal2{
//成员变量：可以是变量，也可以是常量。
int num = 10;//变量
final int num2 = 20;
//抽象类有构造方法吗？？？
//既然我们刚才说过我们的抽象类不能被实例化，为什么抽象类还可以具有构造方法呢？
//这里的构造方法是为了初始化我们的父类数据，并不是用来做一个对象的实例化的
public Animal2(){}
//成员方法：可以是普通成员方法，也可以是抽象方法，
//一个类如果具有抽象方法这个类一定是抽象类
}
public classAbstractDemo2 {
}
packagecom.edu_11;
public abstract class Animal {
private String type;
private String name;
public Animal(){}
public Animal(Stringtype,String name){
this.name = name;
this.type= type;
}
public voidsetType(String type){
this.type = type;
}
public String getType(){
return type;
}
public voidsetName(String name){
this.name = name;
}
public String getName(){
return name;
}
//吃饭的抽象方法
public abstract void eat();
}
packagecom.edu_11;
public class Cat extends Animal{
public Cat(){}
public Cat(Stringname,String type){
setName(name);
setType(type);
}
public void eat() {
System.out.println("猫爱吃鱼");
}
//猫会捉老鼠
public void catchMouse(){
System.out.println("猫会逮老鼠");
}
}
packagecom.edu_11;
public class Dog extends Animal{
public Dog(){}
public Dog(Stringname,String type){
setName(name);
setType(type);
}
public void eat() {
System.out.println("狗爱吃肉");
}
//狗特有的看门方法
public voidlookDoor(){
System.out.println("狗会看门");
}
}
packagecom.edu_11;
public class Test {
public static voidmain(String[] args) {
//利用多态的方式创建一个狗的对象
Animal a = new Dog();
a.eat();
Dog d = (Dog)a;
d.lookDoor();
System.out.println("--------------");
//使用猫的有参构造创建一个对象
Animal a2 = new Cat("bob", "加菲猫");
a2.eat();
System.out.println(a2.getName()+" "+a2.getType());
}
}
packagecom.edu_12;
/**
* 接口的特点：
A:定义接口要用关键字interface表示
格式：interface接口名 {}
B:类实现接口用implements表示
格式：class 类名 implements 接口名 {}
C:接口不能实例化
那么，接口如何实例化呢?
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，接口多态,接口引用指向实现类对象
D:接口的实现类
要么是抽象类
要么重写接口中的所有抽象方法
5.3
接口的成员特点：
A:成员变量
只能是常量。
默认修饰符：publicstatic final
B:构造方法
没有构造方法
C:成员方法
只能是抽象方法。
默认修饰符：publicabstract
*
*/
//定义一个接口
interface inter{
//接口中可以定义那些东西呢？
//1.在接口中定义一些变量
//接口中所有的变量都会默认被final修饰，所以我们的接口中说白了只能定义常量，不能定义变量
//接口中的成员变量不仅被final默认修饰，还被static默认修饰
//我们接口中的变量全部是静态常量
public static final int num = 20;
//2.接口中能否定义一个构造方法呢？？
//接口中不能存在构造方法
//public inter(){}
//3.接口中可以存在普通的成员方法吗？
//接口中的所有方法都是抽象方法
public abstract void show();
}
//定义一个类实现这个接口
class InterImplimplements inter{
@Override
public void show() {
System.out.println("来自接口中扩展的抽象方法");
}
}
//定义一个抽象类，让这个抽象类实现接口,此时这个抽象类不需要重写接口中的抽象方法
abstract classAbstractInterImpl implements inter{}
public classInterfaceDemo {
public static voidmain(String[] args) {
//利用多态的方式将接口进行实例化
inter i = newInterImpl();
//试图更改成员变量的值
//i.num = 30;//接口中所有的变量都会默认被final修饰，所以我们的接口中说白了只能定义常量，不能定义变量
//System.out.println(i.num);
System.out.println(inter.num);
}
}
packagecom.edu_12;
/**
* 5.4
类与类：
继承关系。只能单继承，可以多层(重)继承。
类与接口：
实现关系。可以单实现，也可以多实现。
还可以在继承一个类的同时实现多个接口。
接口与接口：
继承关系。可以单继承，也可以多继承。
interface Inter1{}
interface Inter2{}
interface Inter3 extendsInter2,Inter1{}
//创建一个类实现一个接口,或者多个接口
classInterImpl3 implements Inter1,Inter2{}
//一个类还可以在继承一个类的同时实现多个接口
classInterImpl4 extends InterImpl3 implements Inter3{}
public classInterfaceDemo2 {
}
packagecom.edu_13;
public abstract class Animal {
//私有化成员变量
private String name;
private int age;
//有参无参构造
public Animal(){}
public Animal(String name,int age){
this.name = name;
this.age = age;
}
public voidsetName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
//吃的抽象方法
public abstract void eat();
}
packagecom.edu_13;
public class Cat extends Animal{
public Cat(){}
public Cat(String name,int age){
setAge(age);
setName(name);
}
public void eat() {
System.out.println("猫爱吃鱼");
}
//所有的猫都会逮老鼠
public voidcatchMouse(){
System.out.println("猫会逮老鼠");
}
}
packagecom.edu_13;
public class Dog extends Animal{
//有参无参构造
public Dog(){}
public Dog(String name,int age){
setAge(age);
setName(name);
}
public void eat() {
System.out.println("狗吃骨头");
}
//所有的狗都会看门
public voidlookDoor(){
System.out.println("狗会看家");
}
}
packagecom.edu_13;
public class JumpCat extends Cat implements Inter{
public JumpCat(){}
public JumpCat(String name,int age){
setAge(age);
setName(name);
}
public void jump() {
System.out.println("经过多年的刻苦训练，终于练成了跳高技能");
}
}
packagecom.edu_13;
public class JumpDog extends Dog implements Inter{
public JumpDog(){}
public JumpDog(String name,int age){
setAge(age);
setName(name);
}
public void jump() {
System.out.println("这条狗不简单呐，居然会跳高");
}
}
packagecom.edu_13;
public class Test {
public static voidmain(String[] args) {
//多态的方式创建一个普通狗
Animal a = new Dog();
a.eat();
Dog d = (Dog)a;
d.lookDoor();
System.out.println("------------------");
//创建一个跳高狗
JumpDog jd = newJumpDog();
jd.eat();
jd.lookDoor();
jd.jump();
}
}
