java第三周知识点总结

发布于:2023-01-20 ⋅ 阅读:(17) ⋅ 点赞:(0) ⋅ 评论:(0)

java新手知识第三周

day11-day16

面试题: 成员变量和局部变量的区别:4个

  1. 书写位置不同:1)成员方法:类中方法外;
    2)局部变量:方法定义中或者方法声明上
    2.内存中的位置不一样:1)成:在堆内存中,和对象有关;
    2)局:在栈内存中,和方法有关系;
    3.生命周期:1)成: 随着对象的创建而存在,随着对象的创建完毕而等待JVM的垃圾回收器空闲的时候回收而消失;
    2)局:随着方法的调用而存在,随着方法调用结束而消失;
    4.初始化值不同:1)成:可以不初始化,需要对象名来赋值,存在默认初始化;
    2)局:必须在使用之前进行初始化,不然报错;
    小问题1:那我们在定义变量的时候是定义局部变量还是成员变量呢?
    答:在方法中定义好,占内存小
    小问题2:什么时候把一个变量定义为成员变量呢?
    答:如果一个类能够描述这个事物的属性—成员变量;否则都用局部变量

(重点) this关键字—写一个标准类:this是指的当前类的访问

class StudentTest{ 
public static void main(String[] args){ //匿名对象: 
//需求:访问StudentDemo类的method方法 
new StudentDemo().method(new Student()) ; 
}
 }

与关键字:super的区别和联系:可以跨类去访问父类

代码展示

package com.xy.edu.classtest01;
//
public  abstract class Animal {
    private String name;
    private int age;
    private String color;
    //无参/有参构造方法
    public Animal() {
    }

    public Animal(String name, int age, String color) {
    }

    //公共的访问方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    //抽象方法
    public abstract void eat();
    public abstract void sleep();


}

什么是匿名对象–记住格式

格式: new 类名() ;
1)匿名对象可以作为参数传递 :可以把上面那个代码改进
2)匿名对象可以节省内存空间,因为压根没有栈内存空间,不需要开辟,直接开 辟堆内存空间
3)匿名对象一般适用于一次即可,使用完毕,直接被jvm的GC(垃圾回收器)的回 收;

之前的格式:
类名 对象名=new 类名();
调用方法:对象名.访问成员方法();

匿名对象的格式:
new 类名();
调用方法:new 类名().成员方法名();

代码展示

构造方法的特点以及注意事项(方法名和类名相同)–没有void

  1. 特点:(3个)
  2. 目的:就是为了给类的成员初始化

构造方法有2种:有参构造方法+无参构造方法

注意事项:

  1. 当在书写一个标准类的时候,没有给出任何构造方法,系统会默认提供无参构造法
  2. 如果提供了一个类的有参构造方法,系统就不会构造方法。所以,建议永远给出无参构造方法
  3. 构造方法可以重载;

代码展示

在Java中创建对象就是创建实例–new一个

代码展示

初始化赋值有两种方法:set()以及 有参构造方法+get()

(重点)方法形式参数如果是一个类(引用数据类型),当调用方法时,

package com.qf.args_03;

/**
 *      结论:
 *              1)方法的形式参数如果是基本类型,调用该方法的时候,实际参数需要传递对应数据值即可
 *
 *              2)方法的形式参数是引用类型:数组,类,接口,实际参数在进行传递需要传递当前数组对象 /类的对象/接口的对象
 *                                                              new  :创建实例(堆内存开辟空间:空间地址值)
 */

//定义一个类Demo
class Demo{

    //成员方法
    public int add(int a,int b){ //方法的形式参数是基本类型
        return  a+ b ;
    }
}
//   问题:    测试类中要访问StudentDemo类中的method方法?
//定义一个学生类
class Student{
    public void study(){
        System.out.println("好好学习,天天向上!");
    }
}
//定义一个StudentDemo类对象
class StudentDemo{
    //成员方法method                    //Student s = new Student() ;
    public void method(Student student){ //引用类型:数组,类或者接口    方法形式参数类型:Student类型
                                        //参数名.study():  ---参数名一定要空间地址值,就需要创建具体的学生对象
        student.study() ;
    }
}
//测试类
public class StudentTest {
    public static void main(String[] args) {
        //方法的形式参数是基本类型:简单

        //需要访问Demo类中add方法? 创建Demo类对象,调用add方法
        Demo d = new Demo() ;
        int result = d.add(10,15) ;
        System.out.println("result:"+result);
        System.out.println("----------------------------------------------") ;
        //要访问StudentDemo类中的method方法?
        //1)创建StudentDemo类的对象
        //类名 对象名 = new 类名() ;
        StudentDemo sd = new StudentDemo() ;

        //创建Student类具体对象
       // Student  s = new Student() ;
        sd.method(s) ;//方法的形式参数Student类型,所有需要将Student具体对象创建出来才能调用
    }
}

代码展示

一个类成员的组成以及一个标准类的写法

一个类的组成
1)成员变量 
2)构造方法 
3)成员方法: 
一个类的标准类的写法: 
1)成员变量私有化 
2)无参永远给出的,有参构造根据题意要求(没有明确,全部提供) 
3)成员方法,根据题意要求(没有明确是否带参,是否有返回值,直接输 出语句)

static–静态修饰符(成员方法中去掉静态修饰符),记住他的关键字特点还有应用场景(记忆)

  1. 特点:共有,共享,优先于对象的创建,随着类的加载而加载

代码展示

Javadoc指令产生文档说明书–类似api

写一个工具类,写一个方法,加入文档注释,通过javadoc产生文档说明书

代码块(重点就是优先级)

  1. 优先级:静态代码块>构造代码块>构造方法(有参/无参)
  2. 代码块就是用{}起来的内容
  3. 分类:局部代码块–作用就是–限定局部变量的生命周期;
    构造代码块–在类的成员位置定义的;
    静态代码块–都和类有关系(类就加载一次静态代码块也是只需要加载一次,并且最先加载出来)

继承–extends(关键字)

定义以及好处

  1. 定义:就是将多个类的共性的内容(包括成员变量和成员方法)抽取出来–放在独立的类中;
  2. 好处:有4点:1)就是提高代码的复用性;
    2)可以提高代码的维护性,便于维护,针对子类和父类进行维护(子 父关系明确)
    3)类与类的继承关系–是多态的前提条件

特点:单继承;可以单多层继承,不可以并行多层继承

Java语言不支持多继承,c++可以

Java开发原则:“低耦合,高内聚”

  1. 低耦合:就是类与类的关系越少越好,所以实际开发中要降低耦合性
  2. 内聚性:指的是某个类完成某个功能的一种能力;

子类继承父类,对于非私有的成员,可以直接继承过来;私有的可以通过公共的方法进行访问(重点)

引入关键字super:super可以直接访问父类,代表父类对象空间地址值的饮用,而this是访问本类,也就是当前类,不能跨类访问

继承中成员变量的关系问题:

  1. 如果子类和父类的成员变量不一样
  2. 如果子类的父类的成员变量一样(重点):就近原则
就近原则:
子 子= new 父();

就近原则就是说:子类也没有的去父类的成员变量中去找,没有就报错,绝对不会去父类的局部变量中去找;

继承中的成员方法的关系问题:

1.继承关系中成员变量的访问问题

子类继承父类,如果子类的成员变量名称和父类的成员变量名称不一致,分别访问即可; 如果子类的成员变量和父类的成员变量名称一致:
1)先在子类的局部位置找,是否存在,存在,就使用;
2)如果子类的局部位置没有,在子类的成员位置中找,是否存在,存在就使用;
3)如果子类的成员位置也没有,然后再父类的成员位置找,是否存在,存在就使用;
4)如果父类的成员位置也没有,(父类没有它的父类),就报错,整个类中没有变量; 遵循 “就近原则”

  1. 如果子类和父类的成员方法不一致,那就分别访问;
  2. 如果子类和父类的成员方法一致(指的是返回值类型,修饰符,方法名都一摸一样)的话,引入–方法重写-- override,以及关键字-- final

方法重写-- override

面试题:方法重写override和方法重载overload有什么区别?

 方法重写:出现在继承中, 描述的子类继承父类的时候,可能沿用父亲的功能,而且使用 自己的功能,将父类的功能进行覆盖(复写/重写); 为了让子类具体体现出来的功能信息 举例 动物类 :eat()---->动物饿了都需要吃饭 猫类和狗类:----eat()方法重写,只有看到具体的动物,才能知道具体吃什 么,应该在子类具体体现,将父类的eat重写; 方法重载: 定义方法的时候,方法名相同,参数列表不同,与返回值无关; 目的为保 证这个方法它的扩展性问题,同一个方法,可以不同类的参数; java.lang.Math 求绝对值的方法 
abs(int a) abs(double a)

代码体现:猫狗案例继承版

package com.xy.edu.classtest01;
//
public  abstract class Animal {
    private String name;
    private int age;
    private String color;
    //无参/有参构造方法
    public Animal() {
    }

    public Animal(String name, int age, String color) {
    }

    //公共的访问方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    //抽象方法
    public abstract void eat();
    public abstract void sleep();


}

package com.xy.edu.classtest01;
//狗类
public class Dog extends Animal{
    //无参数/有参构造方法
    public Dog() {
    }
    public Dog(String name, int age, String color) {
        super(name,age,color);
    }
//方法重写
    @Override
    public void eat() {
        System.out.println("狗喜欢吃骨头");
    }

    @Override
    public void sleep() {
        System.out.println("狗喜欢躺着睡");
    }
    //特有功能
    public void kanMen(){
        System.out.println("狗会看门");
    }
}

多态

  1. 概念:具体对象在内存中的变化(对象在不同时刻的类型)
1)宏观角度:现实生活中,一个事物在不同时刻体现不同的形态;
2)微观角度:(内存中的变化)具体对象在内存中的变化(对象在不同时刻的类型)
  1. 多态的前提条件:
1)必须存在方法重写;子类部分功能将父类进行重写
2)必须存在继承关系;
3)必须有父类引用指向子类对象,也就是他的固定格式:父 父 =new 子();
2.1)必须有继承;
2.2)必须存在方法重写-- override;
2.3)必须存在父类引用指向子类对象--向上转型
固定格式:父 父=new 子();

  1. 多态的成员访问特点–孔子装爹(生动形象的通过这个伪代码来加深对这个的理解)
3.1)多态访问成员变量的特点是:编译看左,运行看左;
3.2)多态访问成员方法(非静态)的特点是:编译看左,运行看右;
3.3)多态访问构造方法的特点是:跟继承一样,分层初始化,先父后子,不管是子类的有参还是无参,系统默认优先访问父类的无参构造方法

  1. 多态的格式
  2. 代码体现:父 父 = new 子();这种格式体现的是向上转型,父类引用指向子类对象,如果此时子类里有自己的特有的功能,按照之前的子 子 = new 父();这样的话也行,就是重新开辟堆内存很占空间,所以我通过向下转型(强制转换来实现访问子类特有的功能)格式:子 子=(子)父;这样的好处就是节约内存
public static void main(String[] args) {
        //1.mao
        //1.1接口多态
        Jump jump=new JumpCat();//具体的子实现类--向上转型
        //由于要调用他自己的方法所以强制转换--向下转型
        JumpCat jumpcat=(JumpCat) jump;
        jumpcat.setName("mao");
        jumpcat.setAge(1);
        jumpcat.setColor("blue");
        System.out.println(jumpcat.getName()+jumpcat.getAge()+jumpcat.getColor());
        //调用方法
        jumpcat.eat();
        jumpcat.sleep();//前两个是调用动物类的方法

        String result =jumpcat.catchMouse();//调用自己的特有的方法
        System.out.println(result);
        jump.jump();//调用接口

        //1.2有参数构造方法;;直接具体类对象
        JumpCat ju2=new JumpCat("mao2",2,"blue2");//赋值
        System.out.println(ju2.getName()+ju2.getAge()+ju2.getColor());//打印--展示给自己看的
        ju2.sleep();
        ju2.eat();
        ju2.jump();
        ju2.catchMouse();
        System.out.println("--------------------------------------");

  1. 多态的使用方法
  2. 多态的弊端:因为有继承关系有方法重写,所以这就决定了多态在使用时不能访问子类特有的功能(方法),那如何解决:
7.1)第一种方法就是
子 子=new 父();//这种方法时可以,但是要重新在堆内存中去开辟空间,占内存,空间消耗大---而内存问题是我们实际开发中必须关注的;
7.2)强制转换--向下转型:(向下转型的前提是必须有向上转型)
子 子=(子)父;//好处就是不需要重新new,节省内存//多个栈内存可以指向同一个堆内存

多态的好处–以后多态的应用

抽象类-- abstract:分为抽象类和抽象方法

抽象方法的格式:跟方法的格式一样,只不过不要{}

抽象类的特点:

抽象类的成员特点:
 *      成员变量:抽象类的成员变量既可以有变量,也可以是自定义常量被final
 *      成员方法:抽象类中既可以有抽象方法,也可也有非抽象方法
 *      构造方法:
 *              既可以定义无参/有参构造方法...
 *          存在抽象类多态,有继承关系,初始化的时候,构造方法----分层初始化---->先父类初始化,子类初始化
 *
 *
 *
 *
 *    面试题:
 *                  如果有一个类没有任何的抽象方法,还要将这个类定义为抽象   		类的意义?
 *                        意义:意义就是不能让它new,它如何实例化呢?肯定有具体的子类,进行抽象类多态来操作...
 *                        设计代码(设计层面)
 */
package com.qf.abstract_03;

/**
 * 抽象类的成员特点:
 *      成员变量:抽象类的成员变量既可以有变量,也可以是自定义常量被final
 *      成员方法:抽象类中既可以有抽象方法,也可也有非抽象方法
 *      构造方法:
 *              既可以定义无参/有参构造方法...
 *          存在抽象类多态,有继承关系,初始化的时候,构造方法----分层初始化---->先父类初始化,子类初始化
 *
 *
 *
 *
 *          面试题:
 *                  如果有一个类没有任何的抽象方法,还要将这个类定义为抽象类的意义?
 *                        意义:意义就是不能让它new,它如何实例化呢?肯定有具体的子类,进行抽象类多态来操作...
 *                        设计代码(设计层面)
 */
//人
abstract  class Person{ //抽象类

    //定义一个成员变量
    public int num = 100 ;   //变量

    public final int num2 = 200 ;  //自定义常量  num2不能在改变

    //人都要学习---具体的人才具备具体的动作行为----方法抽象化
    public abstract  void study();

    //无参构造方法
    public Person(){
        System.out.println("这是Person类的无参构造方法");
    }

    public void method(){//非抽象方法
        System.out.println(num) ;
        System.out.println(num2);
    }
}
//学生类
class Student extends  Person{

    //无参构造方法
    public Student(){
        System.out.println("这是Student的无参构造方法");
    }

    @Override
    public void study() {
        System.out.println("学生主要目的学习专业知识");
    }
}

//测试类
public class AbstractDemo2 {
    public static void main(String[] args) {

        //抽象类多态测试
        Person p = new Student() ;
        p.method();

        p.study() ;
    }
}

抽象类的子类:一定得是具体类,不然抽象方法没办法重写,当然如果子类还有子类的话,可以是抽象类

注意事项:有抽象方法的类一定是抽象类,但是抽象类中可以存在抽象方法,也可以有具体的方法;

关键字-- abstract与哪些关键字冲突:

private
final
static
面试题  问题1  :   abstract 和那些关键字冲突
 *private关键字冲突:因为被private私有的成员方法只能在本类访问,abstract修饰的成员方法
 *          必须强制子类重写,已经超出来的当前类的范围
 *
 *final也冲突,final修的成员方法,不能被重写;而抽象方法强制子类必须重写;
 *
 *static也冲突,abstract修饰的方法必须被子类重写,static修饰的方法,算不上抽象,直接跟类相关的;
 *
 *
 *          abstract关键字 应用范围: 定义在类上---抽象类
 *                              定义在方法上----抽象方法
 *                                          public abstract  返回值类型 方法名(空参/带参...)  ;
 *                                          abstract 返回值类型 方法/(空参带参...)  ;
 *
 *   问题2:
 *          子类继承父类,子类重写父类的抽象方法,必须保证访问权限足够大,要么加public要么跟父类的方法保持一致!
 *          否则报错;
 *

关键字–final

final修饰基本数据类型时,数据值不能改变;修饰引用类型时,空间地址值不能改变;

常量:

运行时常量;

自定义常量(final):在实际开发中与static 连用

  1. final关键字的特点:
1)可以修饰类,该类不能被继承
2)可以修饰变量,该变量时一个”常量“,常驻内存;
2.1)修饰成员变量时,必须一开始就赋值,并且只能被赋值一次,否则报错;
final int num=20;
2.2)修饰局部变量时,可以一开始不赋值,但是使用之前必须赋值,并且只能被赋值一次
3)保护数据的安全性;

关键字-- instanceof:用于判断场景用的

接口–interface(关键字)

比抽象类还抽象,和子实现类的关系是:实现–implments
Java后期就是面向接口编程

接口的成员特点

package com.qf.interface_01;

/**
 * 接口---体现事物本身以外的额外功能,需要事物要对接口的功能要进行实现,才具备!
 * 接口的定义
 *      interface 接口名{}   接口和类名的命名规范同理,遵循"大驼峰命名法"
 * 接口的最大特点: 不能实例化
 * 如何实例化?
 *  接口通过它的子实现类进行实例化(前提,这个类实现 implements 接口)
 *  class 子实现类名 implements 接口名{//实现
 *  }
 *
 *  实际开发中:接口的子实现类名的命名---> 接口名的后面+Impl:表示是接口的实现类
 *
 *  接口的成员特点:
 *          1)成员变量:只能是常量,存在默认修饰符 :public static final
 *          2)成员方法:只能是抽象方法,存在默认修饰符  public abstract
 *          3)构造方法:没有构造方法的---通过子实现类的构造方法来实例化
 *
 *          接口本身意义:对外暴露这些功能,让子实现类实现 !
 *
 *
 */
//定义接口
interface Inter{
//    int num = 20 ; //隐藏了默认修饰符public static final 可以省略不写的
    public static final int num = 20 ;

    /*void show(){
        System.out.println("show Inter");
    }*/
    //void show() ; //省略了默认修饰符 public abstract ,可以省略不写
    public abstract  void show() ;

   /* public Inter(){ //不能这样写

    }*/
}
//提供具体的子实现类
                  //实现
class InterImpl implements  Inter{//实现类必须实现接口的抽象方法,否则报错
    @Override
    public void show() {
        System.out.println("show InterImpl");
    }

}

//测试类
public class InterfaceDemo {
    public static void main(String[] args) {
        //创建Inter对象
        //Inter inter = new Inter() ; //接口不能实例化:  Inter is abstract
        //所以,通过接口指向子实现类名
        //接口名 对象名 = new 子实现类名() ;  //接口多态
        Inter inter = new InterImpl() ;
        System.out.println(inter.num); //编译看左,运行看左
        //inter.num = 30 ;  //报错:final修饰的变量:最终的.无法更改的, 不能在被赋值
        System.out.println(Inter.num) ;  //接口比抽象类还抽象  之前:类名.变量名; 变量被static修饰
                                        //接口名.变量名 ; 变量被static修饰
    }
}

package com.qf.interface_04;

/**
 * 什么是接口?
 *      接口体现的是事物的一种额外功能 ;
 *      设计理念:  体现的是一种  "like a"的关系
 *                  跳高猫
 *                  钻火圈狗
 *
 *      之前讲继承的概念--->设计理念体现的是一种"is a"的关系 :什么是什么的一种
 *                  水果
 *                          香蕉
 *                          苹果
 *                          橘子
 *
 *      举例:
 *          猫或者狗事物,本身出生之后不具备"跳高","钻火圈"等等这些额外的行为,但是通过
 *驯兽师 这些人可以将猫和狗训练出来,经过后期的训练,这些事物就具备了这些额外的行为----->这个事物的扩展功能 ;
 *
 * Java编码中,体现这些事物本身不具备的功能,要经过一些特殊的实现才能具备功能-----称为 "接口"---关键字 interface
 *         格式的写法
 *                  interface  接口名{   //命名规范和类名命名一样,见名知意 "大驼峰命名法"
 *                          只能为抽象方法
 *                  }
 *
 *                 接口的子类----"子实现类"
 *                              实现
 *                 class 子类名  implements  接口名{
 *
 *
 *                 }
 *                 //接口比抽象类还抽象---->特点:不能实例化
 */
//定义一个接口 跳高接口
interface Jump{
    /*public void jump(){  //接口中的只能是抽象方法

    }*/
    public abstract void jump() ;//因为 它默认修饰符 public abstract:可以省略不写
}
//跳高猫
 class Cat  implements  Jump{

    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}

//测试类
public class InterfaceDemo {
    public static void main(String[] args) {

        //Jump jump2  = new Jump() ;//接口不能实例化,需要通过子实现类实例化(必须为具体类)
        //测试:接口多态---接口名 对象名 = new 子实现类名();
        Jump jump = new Cat() ;
        jump.jump();
    }
}

接口和抽象类的区别–面试题

接口的应用

package com.xy.edu.classtest01;
//接口
interface Jump {
    //抽象方法
    public  abstract  void jump();

}

package com.xy.edu.classtest01;
//会跳高的猫--首先是猫,就要继承猫的东西---再是会跳,也就是接口
 class JumpCat extends Cat implements Jump {
     //无参数构造方法
    public JumpCat() {
    }
    public JumpCat(String name,int age,String color){
        super(name,age,color);
    }

    //接口--会跳高
     @Override
     public void jump() {
         System.out.println("猫会跳高");
     }
 }

package com.xy.edu.classtest01;
//跳高狗--首先是狗--继承关系--再就是接口(会跳高)
public class JumpDog extends Dog implements Jump{
    public JumpDog() {
    }
    public JumpDog(String name, int age, String color){
        super(name,age,color);
    }
//方法重写
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void sleep() {
        System.out.println("狗躺着睡");
    }

    @Override
    public void jump() {
        System.out.println("狗会跳高");

    }
}

代码体现–猫狗案例–继承多态版引入抽象类引入接口

面试题:面向对象中牵扯的关系

  1. 类和类:继承关系
  2. 类和接口:实现关系
    注意:一个类继承另一个类的同时,可以实现多个接口
  3. 接口和接口:继承关系:extends,不仅支持单继承,也可以多继承;Java本身就是面向接口编程的(Java中最基本的单元就是类)

附一个封装,继承,多态,接口都要的代码

package com.xy.edu.classtest01;
//
public  abstract class Animal {
    private String name;
    private int age;
    private String color;
    //无参/有参构造方法
    public Animal() {
    }

    public Animal(String name, int age, String color) {
    }

    //公共的访问方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    //抽象方法
    public abstract void eat();
    public abstract void sleep();


}

package com.xy.edu.classtest01;
//猫类
public class Cat extends Animal {
   //无参数/有参数构造方法
    public Cat() {
    }

    public Cat(String name, int age, String color) {
        super(name, age, color);
    }

//方法重写
    @Override
    public void eat() {
        System.out.println("猫喜欢吃鱼");
    }

    @Override
    public void sleep() {
        System.out.println("猫喜欢侧着睡");
    }
    //特有功能
    public String catchMouse(){//要么直接输出结果,要么有返回值类型
        return "猫会抓老鼠";
    }
}

package com.xy.edu.classtest01;
//狗类
public class Dog extends Animal{
    //无参数/有参构造方法
    public Dog() {
    }
    public Dog(String name, int age, String color) {
        super(name,age,color);
    }
//方法重写
    @Override
    public void eat() {
        System.out.println("狗喜欢吃骨头");
    }

    @Override
    public void sleep() {
        System.out.println("狗喜欢躺着睡");
    }
    //特有功能
    public void kanMen(){
        System.out.println("狗会看门");
    }
}

package com.xy.edu.classtest01;
//会跳高的猫--首先是猫,就要继承猫的东西---再是会跳,也就是接口
 class JumpCat extends Cat implements Jump {
     //无参数构造方法
    public JumpCat() {
    }
    public JumpCat(String name,int age,String color){
        super(name,age,color);
    }

    //接口--会跳高
     @Override
     public void jump() {
         System.out.println("猫会跳高");
     }
 }

package com.xy.edu.classtest01;
//跳高狗--首先是狗--继承关系--再就是接口(会跳高)
public class JumpDog extends Dog implements Jump{
    public JumpDog() {
    }
    public JumpDog(String name, int age, String color){
        super(name,age,color);
    }
//方法重写
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void sleep() {
        System.out.println("狗躺着睡");
    }

    @Override
    public void jump() {
        System.out.println("狗会跳高");

    }
}

package com.xy.edu.classtest01;
//测试类
public class AnimalTest {

    public static void main(String[] args) {
        //1.mao
        //1.1接口多态
        Jump jump=new JumpCat();//具体的子实现类--向上转型
        //由于要调用他自己的方法所以强制转换--向下转型
        JumpCat jumpcat=(JumpCat) jump;
        jumpcat.setName("mao");
        jumpcat.setAge(1);
        jumpcat.setColor("blue");
        System.out.println(jumpcat.getName()+jumpcat.getAge()+jumpcat.getColor());
        //调用方法
        jumpcat.eat();
        jumpcat.sleep();//前两个是调用动物类的方法

        String result =jumpcat.catchMouse();//调用自己的特有的方法
        System.out.println(result);
        jump.jump();//调用接口

        //1.2有参数构造方法;;直接具体类对象
        JumpCat ju2=new JumpCat("mao2",2,"blue2");//赋值
        System.out.println(ju2.getName()+ju2.getAge()+ju2.getColor());//打印--展示给自己看的
        ju2.sleep();
        ju2.eat();
        ju2.jump();
        ju2.catchMouse();
        System.out.println("--------------------------------------");

        //2.gou
        //2.1接口多态测试
        Jump jd1=new JumpDog();//向上转型--具体实现子类对象
        jd1.jump();//调用接口
        //向下转型
        JumpDog jd02=(JumpDog)jd1;
        //赋值
        jd02.setName("gou");
        jd02.setAge(2);
        jd02.setColor("yellow");
        System.out.println(jd02.getName()+jd02.getAge()+jd02.getColor());
        //调用自己的方法
        jd02.eat();
        jd02.sleep();
        //调用看门
        jd02.kanMen();
        System.out.println("---------------------------------------------");

        //2.2有参数构造方法---具体类对象
        JumpDog ju03=new JumpDog("gou03",3,"yellow03");
        ju03.sleep();
        ju03.eat();//   前两个是动物类的方法--继承过来的
        ju03.kanMen();//自己特有的方法
        ju03.jump();//接口的方法








    }
}