java笔记7，继承和多态 super instanceof 重载和重写的区别 ==与equals()的区别

最新推荐文章于 2021-05-11 22:51:39 发布

莹宝与鑫鑫

最新推荐文章于 2021-05-11 22:51:39 发布

阅读量137

点赞数

分类专栏： # java基础学习笔记

本文链接：https://blog.csdn.net/weixin_38587484/article/details/113612898

版权

java基础学习笔记专栏收录该内容

11 篇文章 0 订阅

订阅专栏

一继承

1.1 语法格式

class Subclass extends SuperClass{

 }

1.2 继承的作用

继承的出现减少了代码冗余，提高了代码的复用性。
继承的出现，更有利于功能的扩展。
继承的出现让类与类之间产生了关系，提供了多态的前提。

1.3 继承的使用注意事项

子类继承了父类，就继承了父类的方法和属性。
在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。
子类不能直接访问父类中私有的(private)的成员变量和方法。
支持单继承和多层继承，不允许多重继承
- 一个子类只能有一个父类
- 一个父类可以派生出多个子类

二子类方法的重写

在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。

2.1 注意事项

子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限
子类不能重写父类中声明为private权限的方法
子类方法抛出的异常不能大于父类被重写方法的异常
子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为 static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。

class Person{
    private void name() {     
    }
}
class Stu extends Person{
    //@Override //父类的方法是private，不能重写
    public void name(){
    }
}

class Person{
    public void name() {     
    }
}
class Stu extends Person{
    // @Override //子类比父类权限小，编译不通过
    // void name(){
    // }
}

三 super关键字

3.1 super的作用

可用于访问父类中定义的属性
可用于调用父类中定义的成员方法
可用于在子类构造器中调用父类的构造器
- 在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
- "super(形参列表)"的使用，必须声明在子类构造器的首行！
- 在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现
- 在构造器的首行，没有显式的声明"this(形参列表)“或"super(形参列表)”，则默认调用的是父类中空参的构造器：super()
- 在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器
当子父类出现同名成员时，可以用super表明调用的是父类中的成员
super的追溯不仅限于直接父类
- 可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，习惯省略"super."
- 当子类和父类中定义了同名的属性时，要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。
- 当子类重写了父类中的方法以后，想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。

3.2 关于调用父类构造器的说明

子类中所有的构造器默认都会访问父类中空参数的构造器
当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器。同时，只能”二选一”，且必须放在构造器的首行
如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错

四多态性

4.1 对象的多态性

父类的引用指向子类的对象，可以直接应用在抽象类和接口上
引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简称：编译时，看左边；运行时，看右边。若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism) 。
多态情况下，“看左边”：看的是父类的引用（父类中不具备子类特有的方法）；“看右边”：看的是子类的对象（实际运行的是子类重写父类的方法）
子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting)。
一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法
子类中定义了与父类同名同参数的方法，在多态情况下，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。

4.2 重载与重写的区别

重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；
重写
- 子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作
- 重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。
- 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
- 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
- 子类不能重写父类中声明为private权限的方法
- 父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
- 父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
- 父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)
- 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型
而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。
子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）

4.3 instanceof 操作符

A instanceof B：检验A是否为类B的对象，返回值为boolean型。
- 要求A所属的类与类B必须是子类和父类的关系，否则编译错误。
- 如果A属于类B的子类C，A instanceof B值也为true。

4.4 对象类型转换(casting)

基本数据类型的Casting：
- 自动类型转换：小的数据类型可以自动转换成大的数据类型，如
```
long g=20;
double d=12.0f
```
- 强制类型转换：可以把大的数据类型强制转换(casting)成小的数据类型,如
```
 float f=(float)12.0;
 int a=(int)1200L
```
对Java对象的强制类型转换
- 从子类到父类的类型转换可以自动进行
- 从父类到子类的类型转换必须通过强制类型转换实现
- 无继承关系的引用类型间的转换是非法的
- 在强制类型转换前可以使用instanceof操作符测试一个对象的类型

4.5 继承成员变量和继承方法的区别

若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中。
对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量

五 Object类

Object类是所有Java类的根父类
如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类

5.1 ==操作符与equals()方法

==操作符

基本类型比较值:只要两个变量的值相等，即为true。

int a=5; 
if(a==6){…}

引用类型比较引用(是否指向同一个对象)：只有指向同一个对象时，==才返回true。

Person p1=new Person();
Person p2=new Person();
if (p1==p2){…}

public class App {
  public static void main(String[] args) {
      Person person = new Person();
      Stu stu = new Stu();
      if (stu==person) {//报错：Incompatible operand types Stu and Person
          System.out.println(1);       
      }
  }
  }
  class Person{

  }
  class Stu{

  }

用“==”进行比较时，符号两边的数据类型必须兼容(可自动转换的基本数据类型除外)，否则编译出错

equals()
- 所有类都继承了Object，也就获得了equals()方法，可以重写。
- equals()只能比较引用类型，如果没有重写的话其作用与“==”相同,比较是否指向同一个对象。
  - 格式:obj1.equals(obj2)
- 当用equals()方法进行比较时，对类File、String、Date及包装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象。
  - 原因：在这些类中重写了Object类的equals()方法。
重写equals()方法的原则
- 对称性：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。
- 自反性：x.equals(x)必须返回是“true”。
- 传递性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。
- 一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。
- 任何情况下，x.equals(null)，永远返回是“false”； x.equals(和x不同类型的对象)永远返回是“false”。

public static void main(String[] args) {
    int it = 65;
    float fl = 65.0f;
    System.out.println("65和65.0f是否相等？" + (it == fl)); //true,inter自动提升为float类型

    char ch1 = 'A'; 
    char ch2 = 12;
    System.out.println("65和'A'是否相等？" + (it == ch1));//true
    System.out.println("12和ch2是否相等？" + (12 == ch2));//true

    String str1 = new String("hello");
    String str2 = new String("hello");
    System.out.println("str1和str2是否相等？"+ (str1 == str2));//false

    System.out.println("str1是否equals str2？"+(str1.equals(str2)));//true
}

equals()重写练习

public class App {
    public static void main(String[] args) {
        Stu stu1 = new Stu("tom", 1);
        Stu stu2 = new Stu("john", 2);
        System.out.println(stu1.equals(stu2)); //false
    }
}
class Stu {
    private String name;
    private int ids;

    public Stu(String name, int ids) {
        this.name = name;
        this.ids = ids;
    }

    public String getName() {
        return name;
    }

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

    public int getIds() {
        return ids;
    }

    public void setIds(int ids) {
        this.ids = ids;
    }

    @Override
    public boolean equals(Object obj) {
        if(this==obj)
            return true;
        if (obj==null) 
            return false;
        if (obj instanceof Stu) {
            Stu other=(Stu)obj;
            if (this.ids == other.getIds()) {
                return true;
            }
        }
        return false;
    } 
}

public class App {
    public static void main(String[] args) {
        MyDate m1 = new MyDate(14, 3, 1976);
        MyDate m2 = new MyDate(14, 3, 1976);
        Object m3=new MyDate(22, 1, 2020);
        System.out.println(m1.getClass()+"-----"+m3.getClass());//class MyDate-----class MyDate
        if (m1 == m2) {
            System.out.println("m1==m2");
        } else {
            System.out.println("m1!=m2"); // m1 != m2
        }
        if (m1.equals(m2)) {
            System.out.println("m1 is equal to m2");// m1 is equal to m2
        } else {
            System.out.println("m1 is not equal to m2");
        }
    }
}

class MyDate {
    private int days;
    private int month;
    private int year;

    public MyDate(int days, int month, int year) {
        this.days = days;
        this.month = month;
        this.year = year;
    }

    @Override
    public boolean equals(Object obj) {
        if(obj == null)
            return false;
        if(obj == this)
            return true;
        if(obj instanceof MyDate){
            MyDate date= (MyDate) obj;
            if (date.month== month && date.year==year && date.days==days) {
                return true;                
            }
        }
        return false;
    }  
}

5.2 toString() 方法

toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址。
在进行String与其它类型数据的连接操作时，自动调用toString()方法

Date now=new Date();
System.out.println(“now=”+now); 
//相当于
System.out.println(“now=”+now.toString());

可以根据需要在用户自定义类型中重写toString()方法,如String 类重写了toString()方法，返回字符串的值。

s1=“hello”;
System.out.println(s1);//相当于System.out.println(s1.toString());

基本类型数据转换为String类型时，调用了对应包装类的toString()方法

int a=10;
System.out.println(“a=”+a);

public class App {
    public static void main(String[] args) {
        Circle c1 = new Circle(1,"red",2);
        Circle c2 = new Circle(1,"red",2);
        System.out.println(c1.equals(c2));
        System.out.println(c1);
        c2 = new Circle(2,"black",2);
        System.out.println(c1.equals(c2));
        System.out.println(c2);
    }
}
class Circle extends GeometricObject{
    private double radius;
    public Circle(){
        super();
        radius=1.0;
    }
    public Circle(double radius){
        super();
        this.radius=radius;
    }
    public Circle(double radius,String color,double weight){
        super(color,weight);
        this.radius=radius;
    }
    public double findArea(){
        return Math.PI*radius*radius;
    }
    public boolean equals(Object obj){
        if(obj==null)
            return false;
        if(obj == this)
            return true;
        if (obj instanceof Circle) {
            Circle cir=(Circle)obj;
            if (cir.radius==radius) {
                return true;
            }
        }
        return false;
    }
    public String toString(){
        return "圆的半径是"+radius;
    }
}
class GeometricObject{
    protected String color; 
    protected double weight;
    protected GeometricObject(){
        color="white";
        weight=1.0;
    }
    protected GeometricObject(String color, double weight){
        this.color=color;
        this.weight=weight;
    }

    public String getColor() {
        return color;
    }

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

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }
}

六包装类(Wrapper)

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

包装类的父类是Number

6.1 基本数据类型包装成包装类的实例 —装箱

通过包装类的构造器实现：

int i = 500; 
Integer t = new Integer(i);

通过字符串参数构造包装类对象：

Float f = new Float("4.56");
Long l = new Long("asdf"); //NumberFormatException

6.2 获得包装类对象中包装的基本类型变量 —拆箱

调用包装类的.xxxValue()方法：

Integer i=new Integer(1);
int y=i.intValue();
System.out.println(y);//1

JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。

6.3 字符串转换成基本数据类型

通过包装类的构造器实现

int i = new Integer("12");

通过包装类的parseXxx(String s)静态方法：

Float f = Float.parseFloat("12.1");

6.4 基本数据类型转换成字符串

调用字符串重载的valueOf()方法

String str = String.valueOf(2.34f);

更直接的方式：

String intStr = 5 + "";

6.4 练习

三元运算符后面二个数值类型得保持一致

Object o1 = true ? new Integer(1) : new Double(2.0);
System.out.println(o1);//1.0，因为要保持一致，1自动提升为1.0
Object o2;
if (true)
    o2 = new Integer(1);
else
    o2 = new Double(2.0);
System.out.println(o2);//1

判断以下输出

Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i == j);//false
Integer m = 1;
Integer n = 1;
System.out.println(m == n);//true
Integer x = 128;
Integer y = 128;
System.out.println(x == y);//false

莹宝与鑫鑫

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
java笔记7，继承和多态 super instanceof 重载和重写的区别 ==与equals()的区别

第六章类的继承和多态一继承1.1 语法格式1.2 继承的作用1.3 继承的使用注意事项二子类方法的重写2.1 注意事项三 super关键字3.1 super的作用3.2 关于调用父类构造器的说明四多态性4.1 对象的多态性4.2 重载与重写的区别4.3 instanceof 操作符4.4 对象类型转换(casting)4.5 继承成员变量和继承方法的区别五 Object类5.1 ==操作符与equals()方法5.2 toString() 方法六包装类(Wrapper)6.1 基本数据类型包装成包
复制链接

扫一扫