java_继承、super、重写、instanceof

本篇文章主要介绍了"java_继承、super、重写、instanceof"，主要涉及到方面的内容，对于Javajrs看球网直播吧_低调看直播体育app软件下载_低调看体育直播感兴趣的同学可以参考一下： /* 在现实生活中事物与事物之间是存在关系.球员---->球队 整体与部分关系 has a 关系 学生----->人 继承的关系 ...

/*
在现实生活中事物与事物之间是存在关系.
    球员---->球队  整体与部分关系   has a 关系  

    学生----->人    继承的关系      is a 关系

*///球员类
class Player{

    int num; //编码    String name;

    publicPlayer(int num , String name){
        this.num = num;
        this.name = name;
    }

    publicvoidrun(){
        System.out.println(name+"开跑...");
    }
}

//球队类
class Team{

    String name;  //球队的名字    Player p1;  //球员1    Player p2;   //球员2    Player p3;  //球员3publicTeam(String name,Player p1,Player p2,Player p3){
        this.name = name;
        this.p1 = p1;
        this.p2 = p2;
        this.p3 = p3;
    }

    //开始比赛publicvoidstartGame(){
        System.out.println(name+"开赛啦！！");
    }
}

class Demo6 
{
    publicstaticvoidmain(String[] args) 
    {
        Player p1 = new Player(12,"梅西");
        Player p2 = new Player(7,"C罗");
        Player p3 = new Player(11,"内马尔");
        //球队
        Team t = new Team("恒大",p1,p2,p3);
        t.startGame();

        System.out.println("名字："+ t.p2.name);
    }
}

/*
目前存在的问题：
1. 无法描述清楚这两个类之间的继承关系。
2. 存在着重复代码。

面向对象的三大特征：
1. 封装
2. 继承
3. 多态.

继承：继承是通过关键字extends体现的。

继承的格式：

class 类名1 extends 类名2{

}

继承要注意的事项：
1. 千万不要为了减少重复代码而去继承，只有真正存在着继承关系的时候才去继承。
2. 父类私有的成员不能被继承。
3. 父类的构造函数不能被继承。
4. 创建子类对象时默认会先调用父类无参的构造函数。

*/

//人类 
class Person{

    String name;

    privateint age;

    publicPerson(String name){
        this.name = name;
    }

    publicPerson(){
        System.out.println("Person类的构造方法被调用了....");
    }

    publicvoideat(){
        System.out.println(name+"在吃饭...");
    }
}

//学生类
class Student extends Person {  // Student 就称作为Person类的子类， Person类就称作为Student的父类(超类、基类)int num; //学号publicStudent(){
        System.out.println("Student类的构造方法被调用了....");
    }

    publicvoidstudy(){
        System.out.println(name+"good good study , day day up");
    }   
}

class Demo7 
{
    publicstaticvoidmain(String[] args) 
    {
        Student s = new Student();

        /*
        s.name = "狗娃";
        System.out.println("名字："+ s.name);
        s.eat();
        */
    }
}

/*
疑问： 为什么要调用父类的构造方法啊？这样子做的意义在那？

    调用父类 的构造方法是可以初始化从父类继承下去的属性的。

*/classFu{int x = 10;

    String name;

    public Fu(String name){
        this.name = name;
        System.out.println("Fu类d带参的构造方法...");
    }

    public Fu(){
        System.out.println("Fu类无参的构造方法...");
    }
}

classZiextendsFu{int x = 20;

    public Zi(String name){
        super(name); //指定调用父类一个参数的构造函数。
    }

    publicvoid print(){
        System.out.println("x1 = "+ x);
    }

}

classDemo8{publicstaticvoid main(String[] args) 
    {
        Zi z = new Zi("大头儿子"); 
        System.out.println("name= "+z.name);

    }
}

/*
super关键字：

super关键字代表了父类空间的引用。

super关键字的 作用：
1. 子父类存在着同名的成员时，在子类中默认是访问子类的成员，可以通过super关键字指定访问父类的成员。
2. 创建子类对象时，默认会先调用父类无参的构造方法，可以通过super关键字指定调用父类的构造方法。

super关键字调用父类构造方法要注意的事项：
1. 如果在子类的构造方法上没有指定调用父类的构造方法，那么java编译器会在子类的构造方法上面加上super()语句。
2. super关键字调用父类的构造函数时，该语句必须要是子类构造函数中的第一个语句。
3. super与this关键字不能同时出现在同一个构造函数中调用其他的构造函数。因为两个语句都需要第一个语句。

super关键字与this关键字的区别：
1. 代表的事物不一致。
1. super关键字代表的是父类空间的引用。
2. this关键字代表的是所属函数的调用者对象。
2. 使用前提不一致。
1. super关键字必须要有继承关系才能使用。
2. this关键字不需要存在继承关系也可使用。
3. 调用构造函数的区别：
1. super关键字是调用父类的构造函数。
2. this关键字是调用本类的构造函数。
*/

class Fu{

    int x = 10;

    String name;

    publicFu(){
        System.out.println("Fu类无参的构造方法..");
    }

    publicFu(String name){
        this.name = name;
        System.out.println("Fu类带参的构造方法..");
    }

    publicvoideat(){
        System.out.println("小头爸爸吃番薯..");
    }
}

class Zi extends Fu{

    int x = 20; 

    int num;

    publicZi(String name,int num){
        super(name); //指定调用了父类带参的 构造方法...this(); // 调用本类无参构造方法..//super(); //指定调用了父类无参构造方法。。。
        System.out.println("Zi类带参的构造方法..");
    }

    publicZi(){
        System.out.println("Zi类无参的构造方法..");
    }

    publicvoidprint(){
        System.out.println("x = " +super.x);
    }

    publicvoideat(){
        System.out.println("大头儿子吃龙虾..");
    }
}

class Demo9 {

    publicstaticvoidmain(String[] args) 
    {
        Zi z = new Zi("狗娃");

    }
}

/*
目前的问题：父类的功能无法满足子类的需求。

方法重写的前提： 必须要存在继承的关系。

方法的重写: 子父类出了同名的函数，这个我们就称作为方法的重写。

什么是时候要使用方法的重写：父类的功能无法满足子类的需求时。

方法重写要注意的事项：
1.方法重写时， 方法名与形参列表必须一致。
2.方法重写时，子类的权限修饰符必须要大于或者等于父类的权限修饰符。
3.方法重写时，子类的返回值类型必须要小于或者 等于父类的返回值类型。
4.方法重写时， 子类抛出的异常类型要小于或者等于父类抛出的异常类型。
Exception(最坏)
RuntimeException(小坏)

方法的重载：在一个类中 存在两个或者两个 以上的同名函数,称作为方法重载。

方法重载的要求
1. 函数名要一致。
2. 形参列表不一致（形参的个数或形参 的类型不一致）
3. 与返回值类型无关。

*/

classAnimal{//大的数据 类型 
}

classFishextendsAnimal{//Fish小 的数据类型。
}

classFu{    String name;

    public Fu(String name){
        this.name = name;
    }

    public Animal eat() throws RuntimeException {
        System.out.println(name+"吃番薯...");
        returnnew Animal();
    }
}

classZiextendsFu{    String num;

    public Zi(String name){
        super(name);//指定调用 父类带参的构造方法
    }

    //重写父类的eat方法public Animal eat() throws Exception{
        System.out.println("吃点开胃菜..");
        System.out.println("喝点汤....");
        System.out.println("吃点龙虾....");
        System.out.println("吃青菜....");
        System.out.println("喝两杯....");
        System.out.println("吃点甜品...."); 
        returnnew Animal();
    }

}

classDemo10{publicstaticvoid main(String[] args) 
    {
        Zi z = new Zi("大头儿子");
        z.eat();

    }
}

/*
instanceof 关键字

instanceof关键字的作用：判断一个对象是否属于指定的类别。

instanceof关键字的使用前提：判断的对象与指定的类别必须要存在继承或者实现的关系。

instanceof关键字的使用格式：

    对象  instanceof 类别

instanceof关键字的作用： 目前没用。但是后天我们学习 到了多态之后就非常有用。
一般我们做强制类型转换之前都会使用该关键字先判断一把，然后在进行转换的。

*/

classAnimal{    String name;

    String color;

    public Animal(String name, String color){
        this.name = name;
        this.color = color;
    }
}

//狗是属于动物中一种classDogextendsAnimal {public Dog(String name,String color){
        super(name,color); //指定调用父类两个 参数的构造函数。
    }

    publicvoid bite(){
        System.out.println(name+"咬人!!");
    }
}

//老鼠 也是属于动物中一种classMouseextendsAnimal{public Mouse(String name,String color){
        super(name,color);
    }

    publicvoid dig(){
        System.out.println(name+"打洞..");
    }

}

classDemo12{publicstaticvoid main(String[] args) 
    {
        Dog d = new Dog("哈士奇","白色");
        System.out.println("狗是狗类吗？"+ (d instanceof Dog));
        System.out.println("狗是动物类吗？"+ (d instanceof Animal));   
        //System.out.println("狗是老鼠类吗？"+ (d instanceof Mouse));      // false true        Animal a = new Animal("狗娃","黄色"); //狗娃是人
        System.out.println("动物都是狗吗？"+ (a instanceof Dog));

    }
}

相关图片

相关文章