Java基础之浅谈继承、多态

一、继承的理解

  • 继承:简单通俗的来讲,继承就是一个类继承另一个类,通常用extends表示继承。
  • 继承的类叫子类,被继承的类叫父类。
  • 子类可以使用父类的变量和方法,同时也可以重写父类的方法。
  • 在Java中没有多继承这一概念,但是有类似多继承的方法!(通常来讲一个父类可以有多个子类,而一个子类只能有一个父类)
//继承简单表示
public class Son extends Father{
//将特殊的方法放在子类中
}
class Father {
//我们通常将一般的方法放在父类中,因为父类的方法子类都可以用。
}

二、super、this、instanceof关键字

this

  • 上一篇文章已经说过了方法重写的概念,在这里就不再重复了。
  • this关键字也在上一篇讲过,我们可以在构造器中通过this()来调用本类的不同参数构造器。通常我们都写在第一行!
  • 还可以通过this.变量的方式表示使用的是本类的变量

super

  • super关键字就是在继承中应用的,我们可以通过super()调用父类的不同参数构造器
  • 同时还可以通过super.方法,调用父类的方法。
  • 同时它也是写在第一行!
  • 通常使用super是因为子类继承了父类,这样子类就不必要在写一些成员变量,直接在构造器中通过super()调用父类的构造器,将参数初始化即可。
public class Son extends Father{
    Son(String name, int age) {
        super(name, age);//如果子类的构造器没有显示的调用父类的构造器,则将默认的调用父类的无参构造。
    }
}
class Father {
    String name;
    int age;
    Father(String name,int age) {
        this.name = name;
        this.age = age;
    }
}
//若父类中没有无参构造,而子类构造器中又没有调用父类的其它构造器,则Java编译器会报错。

对于继承简言之就是:父类有的子类都有,父类没有的子类也可以有

instanceof

public void instanceOf(Animal T) {
        if(T instanceof Dog) { //我们传进来的dog就是此时的T,通过instanceof检测它是否属于Dog或者Animal,可以判断对象的类型。
//此时的语句应该是这样的 Animal T = new Dog(); 而我们应该将T向下转型
            t = (Dog) T;
            System.out.println("yes");
        }
    }
        Animal dog = new Dog();
        Animal cat = new Cat();
        cat.instanceOf(dog);//程序将输出"yes"

三、多态

  • 多态是在继承的基础上实现的。也称之为(向上转型)
  • 大家只需要记住对于成员变量:编译看左边,运行也看左边。
  • 而对于方法:则是编译看左边,运行看右边。
public class Animal {
    public void play() {
        System.out.println("玩");
    }
    public void eat() {
        System.out.println("吃");
    }
}
public class Cat extends Animal{
    public void eat() {
        System.out.println("猫吃饭,亲密度+8");
    }
    public void play() {
        System.out.println("撸猫,体力值-9");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal cat = new Cat();//此时cat被看成是Animal的对象,但实际上本质是Cat的。
//在编译阶段我们看左边,它是Animal骗过编译器,但真正运行的时候它会看右边。
        cat.eat();
        cat.play();
//最终输出“猫吃饭,亲密度+8”和“撸猫,体力值-9”。这就是多态的应用
//看右边,就是先去寻找Cat中是否有重写的父类方法,如果有则调用自己的。如果没有则用父类的。
//可以记为:先调子类,再调父类。
    }
}

Animal cat = new Cat();这也是向上转型,将Cat类的转成了Animal

3.1abstract

  • 抽象类:使用abstract关键字
  • 抽象类中的方法不需要实现,只需要声明占一个位置就行。我们可以在子类中去具体实现这个方法。
  • 这样更有灵活性,就像我们定义了一个抽象方法eat(),而不同的子类可以去实现成不同的方法,猫可以实现吃鱼,狗可以实现吃翔,使程序更加简单化。
  • 抽象类无法实例化,也就不能造对象了。

3.2权限修饰

  1. 再次总结权限修饰范围
  2. 仅对本类可见————private
  3. 对外部完全可见————public
  4. 对本包和所有子类可见————protected
  5. 对本包可见————缺省,也就使默认的

四、Objcet

  • Object是所有类的父类
  • 既是没有明显写出继承Object,但也默认认为Object是父类

4.1equals方法

  • Object类中的equals()方法比较的是内存地址,通常我们都会重写equals()方法,达到值比较的目的。
  • getClass方法将返回一个对象所属的类。我们可以通过它检测两个对象是否属于同一个类。

Java规范要求equals方法具有下面的特性:
1.自反性:对于任何非空引用x,x.equals(x)应该返回true。
2.对称性:对于任何引用x和y,当且仅当y.equals(x)返回true时,x.equals(y)返回true。
3.传递性:对于任何引用x、y和z,如果x.equals(y)返回true,y.equals(z)返回true,则x.equals(z)也应该为true。
4.一致性:如果x和y引用的对象没有发生变化,反复调用x.equals(y)应该返回同样的结果。
5.对于任意非空引用x,x.equals(null)应该返回false。

  • 但是对于一个e是Employee对象,m是Manager对象,并且两个对象的值都是相同的。如果调用e.equals(m)则返回true。若反过来调用m.equals(e)则返回false。这就违反了我们的对称性。
  • 因为我们用的是instanceof检测的,但是父类instanceof子类是无法进行的。所以这也是instanceof的缺点
  • 我们可以通过getClass来比较两个对象是否属于同一个类,但是这样也有限制,就是多态的情况下返回false。

4.2hashCode方法

  • String类计算散列码算法:

点击查看代码

int hash = 0;
    for(int i = 0; i < length(); i++) {
      hash = 31*hash + charAt(i);
  }

– 对于字符串的散列码,是看字符串的内容而定的。意味着两个字符串内容相同,则他们的散列码也相同。

4.3toString方法

  • 其实这个方法非常简单,就是把我们的字段以字符串的形式,好看的输出出来。
@Override
    public String toString() {
        return getClass().getName()
                +"{" 
                + "tili=" 
                + tili 
                + ", qimi=" 
                + qimi 
                + '}';
    }
  • 在使用的时候我们可以写成
  • System.out.println(x.toString());
  • System.out.println(x);这样会默认调用toString()方法,可以简略不写

但是在有时候我们用toString方法是会出现输出java.io.PrintStream@2f6684和[I@1a46e30的情况

1.这是因为Objcet类定义了toString方法,可以打印对象的类名和散列码,所以需要我们对toString方法进行重写
2.数组也继承了Objcet类的toString,如果我们使用时不重写toString,则会出现[I@1a46e30,补救办法就时使用Arrays.toString()
3.若是二维数组,则可以使用Arrays.deepToString()方法
4.强烈建议在每一个类中都重写toString方法。

五、泛型数组列表

  • 在做题时,必须确定数组的长度以后才能够使用,这样使我们非常的不方便!
  • 所以我们就可以使用一个动态扩容的数组,这样就不必定义它的初始化长度。
  • ArraysList list = new ArrayList<>(100) 这是初始化100的数组,可动态扩容
  • 如果说空间过多浪费了,可以使用trimToSize()方法,将没用过的空间释放掉。
  • 具体详细的ArrayList用法,我们在日后的集合学习。

5.1将字符串转成整型

int x = Integer.parseInt(s);

5.2将数字转成字符串

String s = String.ValueOf(x);

5.3可变参数

System.out.println(sum(1,2,3,4,5));
    public static int sum(int... a) {
        int total = 0;
        for(int i:a) {
            total += i;
        }
        return total;
    }

六、枚举类

  • 枚举用enum表示
  • public enum Size{1,2,3,4,5};一次自增1
  • 枚举的构造器总是私有的

七、结尾

  • 对于继承、多态内容就总结这么多,希望大家可以多多练习。如果有不足之处,希望大家多多包涵,多多支持。如果有不懂的地方可以直接私信问我,欢迎来访!
  • 我将会继续更新关于Java的学习知识,感兴趣的小伙伴可以关注一下。
  • 文章写得比较走心,用了很长时间,绝对不是copy过来的!
  • 尊重每一位学习知识的人,同时也尊重每一位分享知识的人。
    原文作者:渔夫会扎蛙
    原文地址: https://www.cnblogs.com/lx-meteor/p/16095211.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞