java面向对象——包+继承+多态(一)-2

简介: java面向对象——包+继承+多态(一)

java面向对象——包+继承+多态(一)-1

https://developer.aliyun.com/article/1503989


protected关键字(重点)

1 在同一个类中

public class time {
    protected int val = 99;

    public static void main(String[] args) {
        time time=new time();
        System.out.println(time.val);
    }
}

此时代码能够正常执行

2 在同一个包中在不同的类

可以看到test与time是在同一个包底下的不同的类,test是可以访问到protected修饰的val

3 不同包底下的子类

在不同包底下,我们要在子类中导入父类,在进行继承,由于是父子类关系,我们要用super关键字对父类中的实例进行访问(super关键字是不能出现在静态方法中的,因为super是对父类对象的引用,是依赖于对象的,而静态方法是属于类的,不依赖于对象)

4 不同包底下的非子类

很明显这是不能进行访问的

访问权限的总结

结合之前我们前面所讲过的public,private,以及包访问权限,现在所学的protected,我们进行一个总结

private:只能在类的内部使用,外部不能进行访问

public:类的外部与内部,同一个包或者不同包下都能进行访问

default(包访问权限):只能在同一个包中进行访问

protected:同一个包,同一个类,不同包的父子类之间都可以进行访问,在父子类中要利用super关键字进行访问,不同包的非子类是不能进行访问的


更复杂的继承关系:(了解)

我们刚才所例举的动物中,对于猫也分为很多种,比如国内的猫种以及国外的猫种,国内的猫种又可以分为那几种等还可以继续细分下去,这种继承关系必须要有逻辑上的联系,不能仅仅为了继承而继承。一般而言我们对于这种复杂的继承关系,一般最好不要超过3层


多态

向上转型(重点)

具体可以看下下列代码

bird bird=new bird(“heihei”,20);


在上面的例子中我们我们知道bird是bird的一个引用,它可以写成下列这种形式


bird bird=new bird(“heihei”,20);

animal bird2 = bird;

//或者写成这个样子

animal bird2 = new bird(“heihei”,20);


此时这种写法就被称作向上转型,也就是父类的引用去引用了子类的对象。


向上转型发生的时机:

1 直接赋值法

这个方法其实就是我们刚才在介绍向上转型的时候所介绍的那个例子。

2 作为返回值

  public static void main(String[] args) {
        animal animal=func();
    }
    public static animal func(){
        bird bird=new bird("gas",39);
        return bird;
    }

3 方法的参数

   public static void main(String[] args) {
        bird bird =new bird("aio",39);
        func(bird);
    }
    public static void func(animal animal){
       animal.eat();
    }

动态绑定(重点)

发生的条件:

1 发生了向上转型(父类引用引用了子类的对象)

2 通过父类的引用,调用父类与子类同名的覆盖方法

动态绑定也被叫做运行时多态(至于具体什么是多态,在下文会具体介绍),也就是在运行时才确定调用的是子类的eat方法

class animal{
    public String name;
    public int age;
    public void eat(){
        System.out.println(name+"eat()"+age);
    }
    public animal(String name,int age){
        this.name=name;
        this.age=age;
    }
}
class bird extends animal{
    public bird(String name,int age){
        super(name,age);
    }
    @Override
    public void eat() {
        System.out.println(name+"吃");
    }
    public void fly(){
        System.out.println("fly()");
    }
}
public class blos {
    public static void main(String[] args) {
        animal animal=new bird("hsd",34);
        animal.eat();
    }
}

我们首先可以从main函数入手,可以看到,animal调用用eat方法,可以看到并没有执行父类中的eat方法,而是调用了子类中同名且参数相同,返回值相同的eat方法,此时我们就说发生了动态绑定,而eat方法也被称作覆盖方法,在这个过程我们就说eat发生了重写,并且可以用@override进行标注


静态绑定:

与动态绑定不同,静态绑定在编译时就确定调用了子类的eat方法

public class blos {
    public static void main(String[] args) {
        duck duck=new duck();
        duck.fun("haha");
    }
}
class duck{
    public void fun(){
        System.out.println("无参");
    }
    public void fun(String name){
        System.out.println("一个参数");
    }
    public void fun(String name,int age){
        System.out.println("两个参数");
    }
}

当duck调用fun方法时,给fun传了几个参数,就对应调用那个方法,这个时候我们就说发生了静态绑定,可以知道静态绑定则需要发生在重载的情况下,而动态绑定则需要先发生重写。

重写的注意事项

1 被final修饰的方法不能发生重写

2 被private修饰的方法不能重写

3 被static修饰的方法不能重写

4 子类方法的修饰限定符要大于父类的修饰限定符


重写与重载的区别

1 重写的返回值要一样(这里有个特殊情况,就是可以是协变类型也是可以的),重载是与返回值无关的

2 重写与重载的方法名都要相同的

3 重写的方法参数要一致,重载的方法参数要不同(这里的方法参数包括含参种类以及含参的个数)


结语:

在后面的一篇文章中,我们会继续详细的讲解什么是多态,什么是抽象类,什么是接口。希望本篇文章能够对于你有所帮助!
目录
相关文章
|
20小时前
|
Java 数据安全/隐私保护 开发者
Java是一种完全支持面向对象编程的语言,其面向对象特性包括封装、继承、多态和抽象等
【6月更文挑战第18天】**面向对象编程(OOP)通过对象封装状态和行为,实现问题域的抽象。Java全面支持OOP,核心特性包括**: - **封装**:保护数据安全,隐藏内部细节。 - **继承**:子类继承父类属性和行为,促进代码重用。 - **多态**:一个接口多种实现,增强灵活性和扩展性。 - **抽象**:通过接口和抽象类抽离共性,简化复杂性。 **Java的OOP便于理解和解决复杂系统问题。**
12 3
|
21小时前
|
安全 Java 开发者
类与对象:Java中的封装、继承与多态
Java面向对象三大特性:封装(隐藏对象细节,增强安全与复用),继承(代码复用与扩展,如Dog继承Animal),多态(统一接口,不同实现,如Playable接口的Piano和Guitar)。通过示例展示了如何在实践中应用这些概念。【6月更文挑战第16天】
|
1天前
|
Java 开发者 C++
Java面向对象的终极挑战:抽象类与接口的深度解析!
【6月更文挑战第17天】在Java OOP中,抽象类和接口助力代码复用与扩展。抽象类不可实例化,提供通用框架,适合继承;接口包含纯抽象方法,支持多态与松耦合。选择抽象类用于继承已有方法和状态,接口则适用于不相关类共享行为。Java 8后接口能含默认方法,增加设计灵活性。抽象类与接口常结合使用,以实现最佳设计,如`Shape`抽象类实现`Drawable`和`Selectable`接口,展现两者协同优势。理解和熟练运用这对概念是提升代码质量的关键。
|
1天前
|
Java
Java多态:如何实现“一箭双雕”的编程艺术?
【6月更文挑战第17天】Java中的多态是编程灵活性的关键,它允许通用接口处理不同类型的对象。通过抽象基类或接口,子类可以实现各自的行为。例如,在动物音乐会场景中,一个`Animal`接口让狮子、猴子和企鹅都能唱歌,调用`sing()`即自动匹配相应行为。同样,在图形绘制示例中,`Shape`基类让绘制圆形、正方形和三角形变得简单,只需调用`draw()`。多态减少了代码冗余,增强了可扩展性和可维护性,是解决需求变化的利器。
|
1天前
|
算法 Java 程序员
Java多态:不只是代码,更是思想的碰撞!
【6月更文挑战第17天】Java的多态性展示了编程的哲学,通过抽象基类(如`AudioFile`、`Shape`、`Product`)和重写方法实现。案例中,音乐播放器利用多态统一处理不同音频格式,绘图软件优雅地绘制各种形状,电商系统灵活管理商品信息。多态简化代码,增强可扩展性,连接技术与设计,体现代码的灵活性和艺术性。
|
6天前
|
Java 编译器 开发者
Java基础3-JVM层面理解Java继承、封装、多态的实现原理(二)
Java基础3-JVM层面理解Java继承、封装、多态的实现原理(二)
7 0
|
6天前
|
存储 Java 索引
Java基础3-JVM层面理解Java继承、封装、多态的实现原理(一)
Java基础3-JVM层面理解Java继承、封装、多态的实现原理(一)
12 0
|
18天前
|
Java 数据安全/隐私保护
Java的封装、继承与多态技术性文章
Java的封装、继承与多态技术性文章
20 1
|
27天前
|
Java 编译器
java类和对象:继承、多态、接口、抽象类-2
java类和对象:继承、多态、接口、抽象类
33 0
|
27天前
|
Java 编译器
java类和对象:继承、多态、接口、抽象类-1
java类和对象:继承、多态、接口、抽象类
14 0