(五)java继承、重写、多态、装箱拆箱

最新推荐文章于 2024-06-13 08:37:22 发布

ANONYMOUS%

最新推荐文章于 2024-06-13 08:37:22 发布

阅读量38

点赞数

分类专栏： Step1 文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_55439500/article/details/131880386

版权

Step1 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

1. 继承

子类继承了父类，就继承了父类的方法和属性。
在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。
在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”。
类继承语法规则： class Subclass extends SuperClass{ }
子类不能直接访问父类中私有的(private)的成员变量和方法。
Java只支持单继承和多层继承，不允许多重继承即：父类只能有一个，但可以存在爷爷类

2. 重写

子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限
子类不能重写父类中声明为private权限的方法
子类方法抛出的异常不能大于父类被重写方法的异常

3. 修饰符

修饰符	当前类	当前包	不同包的子类	工程内
private	yes
default	yes	yes
protected	yes	yes	yes
public	yes	yes	yes	yes

public class Parent {
    private int b;
    int a; //default
    protected int c;
    public int d;
    private void f2() {
        System.out.println("f2" + b);
    }
    void f1() {
        System.out.println("f1");
    }
    protected void f3() {
        System.out.println("f3");
    }
    public void f4() {
        System.out.println("f4");
    }
}

同包下的Children类
public class Children {
    public class AChildren extends Parent {
        public void f5() {
            Parent p = new Parent();
            //1. 不能访问私有变量
//        p.b; //报错
//        p.f2(); //报错，因为不能访问其他类的private

            //2. default，不带修饰符，包内可以访问
            System.out.println(p.a);
            System.out.println(super.a);
            p.f1();

            //3.protected（类，包，子类)
            System.out.println(p.c);
            System.out.println(super.c);
            f3();

            //3.public（当前类，当前包，子类, 所有)
            System.out.println(p.d);
            System.out.println(super.d);
            f4();
            System.out.println("f5");
        }
    }
}

不同包下的Children类
import test3.a.Parent;
public class Children  extends Parent{
        public void f5() {
            Parent p = new Parent();
            //1.private
//        p.b; //报错
//        p.f2(); //报错，因为不能访问其他类的private

            //2. default，不同包下，所以报错
//        System.out.println(p.a);
//       System.out.println(super.a);
//        p.f1();
            //3.protected 只能在同(类，包，子类)
//        System.out.println(p.c); //这个是new了一个Parent的对象，并使用该对象的引用，没有体现出子类的调用,所以报错
            System.out.println(super.c);
            System.out.println(this.c);//因为继承了父类，所以protected修饰的属性可以被访问
            this.f3();//同上

            //4.public（当前类，当前包，子类, 所有)
            System.out.println(p.d);
            System.out.println(super.d);
            f4();
            System.out.println("f5");
        }
}

4. super

super和this的用法相像， this代表本类对象的引用， super代表父类的内存空间的标识
super.name是从父类中开始查找，直接跳过子类
当子类中有和父类的成员（属性和方法）重名时，访问父类的方法通过使用super
子类必须调用父类的构造器，完成初始化
在构造器中super()和this()不能同时出现，但可出现super() ;下一行出现this.name = name
在构造器中super和this必须放在代码块的第一行
在构造器中父类的构造器可以选择，只需加上super("Tom")即可调用父类带一个参数的构造器

class Base{//父类
    public Base(){
        System.out.println("Base()方法被调用")
    }
    public Base(String name){
        System.out.println( this.name+ "Base()方法被调用")
    }
}
class Sub extends Base{//子类
    public Sub(){
        //默认存在super();
        //super("Tom");
        System.out.println("Sub()方法被调用")
    }   
	public static void main( String[] args){
    	Sub sub = new Sub();
	}
}
/*输出   Base()方法被调用
		Sub()方法被调用

4.1 super和this的区别

NO	区别点	this	super
1	访问属性	从本类中开始访问属性，如果没有，则往上（父类中）找，直到Object类	从父类开始访问属性
2	调用方法	同上	从父类开始访问方法
3	调用构造器	调用本类构造器，必须放在构造器的首行	调用父类构造器，必须放在首行
4	特殊	表示当前对象	子类中访问父类对象

5. 多态

编译类型在定义对象时就确定了，不能改变
运行类型可以改变
等号左边是编译类型，右边是运行类型
如：Animal animal = new Cat("喵小喵");//也可叫做向上转型

可以调用父类中的所有成员(遵循访问权限) 调用看编译类型即animal类型
不能调用子类中的特有成员
animal.catchMouse()//报错，catchMouse是Cat的特有方法
能调用的方法最终运行效果看子类的具体实现, 即：先看子类，子类没有看父类，
属性没有重写之说,属性的值直接看编译类型。

5.1 instanceof使用

instanceof比较操作符，用于判断对象的运行类型是否为xx类型或xx类型的子类型

5.2 向下转型(强转)

//instanceof经常和向下转型 一块使用如下：
public void function(Animal animal){
        animal.eat();
        animal.shout();
        if (animal instanceof Dog) {//解释：如果该类型的编译类型时Dog那么返回true
            ((Dog) animal).watchDoor();//此处为向下转型
        }
        if (animal instanceof Cat) {
            ((Cat) animal).obedient();
        }
    }

6. java.lang.Object对象

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

No	方法名称	类型	描述
1	public Object()	构造	构造器
2	public boolean equals(Object obj)	普通	对象比较
3	public int hashCode()	普通	取得Hash码
4	public String toString()	普通	对象打印时调用

6.1 ==和equals

==：
- 基本类型比较：只用两个变量值相等，即为true
- 引用类型比较引用（是否指向同一个对象）：只有指向同一个对象时也就是内存地址相等时才返回true
equals：
- equals()：所有类都继承了Object，也就获得了equals()方法。可以重写，默认比较内存地址相等与”==“；
- 特例：当用equals()方法进行比较时，对类file、String、Data及包装类来说，是比较类型及内容而不考虑引用是否是同一个对象；在这些类中重写了Object类的equals()方法
- 当自定义使用equals()时，可以重写。用于比较两个对象的”内容“是否相等

6.2 toString

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

Data now =new Data();
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());

7. 自动装箱和拆箱

装箱：基本数据类型包装成包装类的实例
- 通过包装类的构造器实现：int i = 500;Integer t = new Integer(i);
- 通过字符串参数构造包装类对象：Float f = new Float("4.56");
拆箱：获得包装类对象中包装的基本类型变量，方法时调用包装类的.xxxValue()方法：boolean b = bobj.booleanValue();
自动装箱，自动拆箱：JDK1.5支持自动装箱和拆箱
字符串转换成基本数据类型
- 通过包装类的构造器实现：int i = new Integer("12")
- 通过包装类的parseXxx(String s)静态方法：Float f = Float.parseFloat("12.1");
基本数据类型转换成字符串
- 调用字符串重载的valueOf()方法：String fstr = String.valueOf(2.34f);
- 更直接的方法：String intStr = 5 + " "

package test10;
import com.sun.jdi.BooleanValue;
public class Test {
    public void Method1() {
        //装箱,先将String类型转为int类型，在包装成包装类
//      Integer i = new Integer("100");
//      Integer i1 = new Integer(123); 装箱
        //不同的基本数据类型的装箱操作
        Integer n1 = 127;
        Integer n2 = 127;
        Float f = 123.0f;
        Double d = 123.1;
        Boolean b1 = false;
        System.out.println("=====以上都为装箱======");
        //先装箱再拆箱操作如下：
        Integer i1 = new Integer(123);//装箱
        Integer i2 = new Integer(123);//装箱
        int i3 = i1.intValue();//拆箱
        Boolean b2 = new Boolean(false);
        boolean b3 = b2.booleanValue();
        System.out.println("====下面的为数据值的测试====");
        System.out.println(i1 == i2);//不相等，new后i1和i2所指向的对象不同
        System.out.println(i1 == i3);//相等，如果有一个是基本数据类型，那么包装类自动拆箱
        System.out.println(n1 == n2);//相等，n1,n2均不超过127，所以返回数值
        Integer n3 = 128;
        Integer n4 = 128;
        System.out.println(n1 == n3);//不相等，n3超过了128，所以返回一个地址，因此不相等
        System.out.println(n4 == n3);//不相等，n3,n4都超过了128，所以返回地址不同，因此不相等
    }
    public static void main(String[] args) {
        Test test = new Test();
        test.Method1();
    }
}
}