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();//接口的方法
}
}