Java|类的初始化顺序、属性覆盖、类的访问权限、面向对象

最新推荐文章于 2024-08-15 14:47:41 发布

weixin_33852020

最新推荐文章于 2024-08-15 14:47:41 发布

阅读量104

点赞数

文章标签： java python

原文链接：https://my.oschina.net/u/2529084/blog/849967

版权

2019独角兽企业重金招聘Python工程师标准>>>

一：继承变量（属性）的覆盖

问题描述：

变量(或者叫做类的属性)，在继承的情况下，如果父类和子类存在同名的变量会出现什么情况？

答案：

1、变量的类型影响属性的取值。

2、修饰符(protected、public、friendly)不影响属性覆盖。

3、final_var常量可以覆盖。

4、var_变量（除去private）不可覆盖。

5、static_var静态变量、static_final静态常量（两者都属于类）不可覆盖。

二：类访问权限

java里面分为4类权限：friendly、private、protected、public

friendly权限：

不加任何权限修饰符，在同一个包中可以访问。即使是子类，如果不在同一个包中也无法访问。

private权限：

私有权限，用private来修饰，只有这个类可以访问，其它类（即使是子类）都不可以访问。

protected权限：

继承访问权限，这个类及其子类可以访问。同时protected权限还提供包访问权限，就是在同一个包下面都可以访问。

public权限：

公共权限，即最开放的权限，可以随意访问。

三：类的初始化顺序

注释：静态常量排在最前面。。。测了下。。。没得出什么结果。。。

1、{静态常量} > {静态变量、静态初始化快} > {变量、初始化块} > 构造函数

2、在遵守1的前提下，按照定义顺序初始化

3、在遵守1 & 2 的前提下，按照

父类的 {静态变量，静态初始化块}

子类的{静态变量，静态初始化块}

父类的{ 变量、初始化块}

父类构造函数

子类的{ 变量、初始化块}

子类的构造函数

四：传值和传引用

1、基本类型变量：char、byte、short、int、long、float、double、boolean

2、引用类型变量：类、接口、数组

结论：

1、基本类型和基本类型变量被当作参数传递给方法时，为值传递。在方法体中，无法给变原变量赋新值，也无法改变它的值。

2、对象和引用型变量被当作参数传递给方法时，在方法体中，无法给原变量赋新值。但是可以改变引用所指对象的属性。

五：继承、多态、overload、overwrite

面向对象三特征：封装、多态、继承（组合）

继承的好处是复用原有类。除了继承Inhericance外，还可以通过组合Composition的方式复用类。

如果存在一种IS-A的关系，并且一个类需要向另一个类暴露所有的方法接口，那么更应该用继承。

如果存在一种HAS-A的关系，那么更应该运用组合。

Composition组合

interface Attack {
    public void move();
    public void attack();
}

class AttackImpl implements Attack {
    private String move;
    private String attack;
 
    public AttackImpl(String move, String attack) {
        this.move = move;
        this.attack = attack;
    }
 
    @Override
    public void move() {
        System.out.println(move);
    }
 
    @Override
    public void attack() {
        move();
        System.out.println(attack);
    }
}

class Insect {
    private int size;
    private String color;
 
    public Insect(int size, String color) {
        this.size = size;
        this.color = color;
    }
 
    public int getSize() {
        return size;
    }
 
    public void setSize(int size) {
        this.size = size;
    }
 
    public String getColor() {
        return color;
    }
 
    public void setColor(String color) {
        this.color = color;
    }
}

class Bee extends Insect implements Attack {
    private Attack attack;
 
    public Bee(int size, String color, Attack attack) {
        super(size, color);
        this.attack = attack;
    }
 
    public void move() {
        attack.move();
    }
 
    public void attack() {
        attack.attack();
    }
}

Inheritance继承

Java类分为：

1、类：使用class定义，不包含抽象方法

2、抽象类：使用absract class定义的类，可以不包含抽象方法

3、接口：使用interface定义的类

Java类的继承规律：

1、类可以继承(extends)类，可以继承(extends)抽象类，可以继承(implements)接口。

2、抽象类可以继承(extends)类，可以继承(extends)抽象类，可以“继承”(implements)接口。

3、接口只能继承(extends)接口。

4、类（类、抽象类）是单一继承；接口允许多继承接口；类和抽象类允许实现多个接口。

5、抽象类继承抽象类、接口，允许缺省实现父级的abstract方法、接口。

6、类继承抽象类或者实现接口，必须全部实现抽象类的抽象方法，或者父级接口的全部接口。

类的多继承缺点：
1、如果多继承，当父类方法重名，会产生歧义
2、如果多继承，当父类方法重名，子类没有overwrite，会产生歧义
接口可以用来设计多继承，同时接口可以避免上述问题

Polymorphism多态

继承是多态得以实现的基础。多态就是一种类型表现出多种状态。

一个方法调用同这个方法所属的主体(也就是对象或类)关联起来叫做绑定，分前期绑定和后期绑定。

1. 前期绑定:

在程序运行之前进行绑定，由编译器和连接程序实现，又叫做静态绑定。比如static方法和 final

方法，注意，这里也包括private方法，因为它是隐式final的。

2. 后期绑定:

在运行时根据对象的类型进行绑定，由方法调用机制实现，因此又叫做动态绑定，或者运行时

绑定。除了前期绑定外的所有方法都属于后期绑定。

多态就是在后期绑定这种机制上实现的。多态消除了类之间的耦合关系，使程序更容易扩展。

Overload Overwrite

重载和重写都是针对方法的概念。方法的型构(英文名是signature，有的译作“签名”，虽然它被使用的较为广泛，但是这个翻译不准确的)。型构就是指方法的组成结构，具体包括方法的名称和参数，涵盖参数的数量、类型以及出现的顺序，但是不包括方法的返回值类型，访问权限修饰符，以及abstract、static、final等修饰符。比如下面两个就是具有相同型构的方法

 public void method(int i, String s) {
        // do something
}
public String method(int i, String s) {
        // do something
}

    重写，英文名是overriding，是指在继承情况下，子类中定义了与其基类中方法具有相同型构的新方

法，就叫做子类把基类的方法重写了。这是实现多态必须的步骤。

    重载，英文名是overloading，是指在同一个类中定义了一个以上具有相同名称，但是型构不同的方
    
法。在同一个类中，是不允许定义多于一个的具有相同型构的方法的。

常见题目1

转载于:https://my.oschina.net/u/2529084/blog/849967