java新手知识第三周
day11-day16
面试题： 成员变量和局部变量的区别:4个
- 书写位置不同：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
- 特点：（3个）
- 目的：就是为了给类的成员初始化
构造方法有2种：有参构造方法+无参构造方法
注意事项：
- 当在书写一个标准类的时候，没有给出任何构造方法，系统会默认提供无参构造法
- 如果提供了一个类的有参构造方法，系统就不会构造方法。所以，建议永远给出无参构造方法
- 构造方法可以重载；
代码展示
在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–静态修饰符（成员方法中去掉静态修饰符），记住他的关键字特点还有应用场景（记忆）
- 特点：共有，共享，优先于对象的创建，随着类的加载而加载
代码展示
Javadoc指令产生文档说明书–类似api
写一个工具类，写一个方法，加入文档注释，通过javadoc产生文档说明书
代码块（重点就是优先级）
- 优先级：静态代码块>构造代码块>构造方法（有参/无参）
- 代码块就是用{}起来的内容
- 分类：局部代码块–作用就是–限定局部变量的生命周期；
构造代码块–在类的成员位置定义的；
静态代码块–都和类有关系（类就加载一次静态代码块也是只需要加载一次，并且最先加载出来）
继承–extends(关键字)
定义以及好处
- 定义：就是将多个类的共性的内容（包括成员变量和成员方法）抽取出来–放在独立的类中；
- 好处：有4点：1）就是提高代码的复用性；
2）可以提高代码的维护性，便于维护，针对子类和父类进行维护（子 父关系明确）
3）类与类的继承关系–是多态的前提条件
特点:单继承；可以单多层继承，不可以并行多层继承
Java语言不支持多继承，c++可以
Java开发原则：“低耦合，高内聚”
- 低耦合：就是类与类的关系越少越好，所以实际开发中要降低耦合性
- 内聚性：指的是某个类完成某个功能的一种能力；
子类继承父类，对于非私有的成员，可以直接继承过来；私有的可以通过公共的方法进行访问（重点）
引入关键字super：super可以直接访问父类，代表父类对象空间地址值的饮用，而this是访问本类，也就是当前类，不能跨类访问
继承中成员变量的关系问题：
- 如果子类和父类的成员变量不一样
- 如果子类的父类的成员变量一样（重点）：就近原则
就近原则：
子 子= new 父（）；
就近原则就是说：子类也没有的去父类的成员变量中去找，没有就报错，绝对不会去父类的局部变量中去找；
继承中的成员方法的关系问题：
1.继承关系中成员变量的访问问题
子类继承父类,如果子类的成员变量名称和父类的成员变量名称不一致,分别访问即可; 如果子类的成员变量和父类的成员变量名称一致:
1)先在子类的局部位置找,是否存在,存在,就使用;
2)如果子类的局部位置没有,在子类的成员位置中找,是否存在,存在就使用;
3)如果子类的成员位置也没有,然后再父类的成员位置找,是否存在,存在就使用;
4)如果父类的成员位置也没有,(父类没有它的父类),就报错,整个类中没有变量; 遵循 “就近原则”
- 如果子类和父类的成员方法不一致，那就分别访问；
- 如果子类和父类的成员方法一致（指的是返回值类型，修饰符，方法名都一摸一样）的话，引入–方法重写-- 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）宏观角度：现实生活中，一个事物在不同时刻体现不同的形态；
2）微观角度：（内存中的变化）具体对象在内存中的变化（对象在不同时刻的类型）
- 多态的前提条件：
1）必须存在方法重写；子类部分功能将父类进行重写
2）必须存在继承关系；
3）必须有父类引用指向子类对象，也就是他的固定格式：父 父 =new 子（）；
2.1）必须有继承；
2.2）必须存在方法重写-- override；
2.3）必须存在父类引用指向子类对象--向上转型
固定格式：父 父=new 子（）；
- 多态的成员访问特点–孔子装爹（生动形象的通过这个伪代码来加深对这个的理解）
3.1）多态访问成员变量的特点是：编译看左，运行看左；
3.2）多态访问成员方法（非静态）的特点是：编译看左，运行看右；
3.3）多态访问构造方法的特点是：跟继承一样，分层初始化，先父后子，不管是子类的有参还是无参，系统默认优先访问父类的无参构造方法
- 多态的格式
- 代码体现：父 父 = 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("--------------------------------------");
- 多态的使用方法
- 多态的弊端：因为有继承关系有方法重写，所以这就决定了多态在使用时不能访问子类特有的功能（方法），那如何解决：
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 连用
- 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("狗会跳高");
}
}
代码体现–猫狗案例–继承多态版引入抽象类引入接口
面试题：面向对象中牵扯的关系
- 类和类：继承关系
- 类和接口：实现关系
注意：一个类继承另一个类的同时，可以实现多个接口 - 接口和接口：继承关系：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();//接口的方法
}
}
本文含有隐藏内容，请 开通VIP 后查看