当前位置：首页 > news >正文

如何更好的建设和维护网站怎么做网络广告

news 2025/7/18 10:51:44

如何更好的建设和维护网站,怎么做网络广告,dhl网站做形式发票,晋中住房与城乡建设厅网站OOP(面向对象编程)具有三大特性（继承、封装、多态），了解之后总结如下： 封装继承向上转型向下转型重写运行时绑定（动态绑定）多态封装封装的本质是让类的调用者不必太多类的实现者是如何实现类的&#x…

OOP(面向对象编程)具有三大特性（继承、封装、多态），了解之后总结如下：

封装
继承
向上转型
向下转型
重写
运行时绑定（动态绑定）
多态

封装

封装的本质是让类的调用者不必太多类的实现者是如何实现类的，只知道如何使用类就行了。
public修饰的成员变量或成员方法，可以直接被类的调用者使用。
private修饰的成员变量或成员方法，不可以直接被类的调用者使用。
当要获取或者修改private属性，就需要getter/setter方法了。。注意以下几点：

a. getName 即为 getter 方法, 表示获取这个成员的值。
b. setName 即为 setter 方法, 表示设置这个成员的值.。
c. 当set方法的形参名字和类中的成员属性的名字一样的时候，如果不使用this, 相当于自赋值. this 表示当前实例的引用。
字段 vs 属性：我们通常将类的数据成员称为 "字段(fifield)" , 如果该字段同时提供了 getter / setter 方法, 那么我称它为“属性”。

继承

继承（is - a）的实质就是减少重复代码的出现。用extends关键字进行继承。如 A extends B:那么B就称为父类（基类或超类），A就称为子类（派生类）。Java中的继承是单继承。

那么子类到底继承了父类什么呢？子类继承了父类除了构造函数外的所有。子类继承了父类，子类需要帮助父类进行构造。
我觉得这句话是太太太重要了，以下都是围绕这句话展开。

首先，子类继承了父类public的字段和方法。对于父类的privata的字段和方法，子类是无法访问的。 protected修饰的字段和方法，子类是可以访问的。

子类不能继承父类的构造方法，因此要帮助父类进行构造，就引入了super关键字，super可以调用父类的构造方法，必须放在第一行，因为构造子类必须先要构造父类。

如果在继承关系中加入代码块，它们的执行顺序：
父类的静态代码块 (执行一次)> 子类的静态代码块(执行一次) > 父类实例代码块 > 父类构造代码块 > 子类实例代码块 > 子类构造代码块

向上转型

向上转型是从子类-->父类，那也就是一个较专用类型向较通用类型转换，因此比较安全。

public class Animal {protected  String name;public Animal(String name) {this.name = name;}public void eat() {System.out.println("吃饭饭"); }
}class Cat extends Animal {public Cat(String name) {//使用super调用父类的构造方法super(name);}
}class Bird extends Animal {public Bird(String name) {super(name);}public void fly() {System.out.println("飞飞飞");}
}

若执行：

Aniamls bird = new Bird("二哈")

就是向上转型，即父类 Aniamls引用子类的 Bird对象。

向上转型发生的时机：
1、直接赋值

 Animal animal = new Bird("二哈");animal.x;

此时要注意：animal是父类的引用，它只能调用自己的方法或者访问自己的属性。
虽然animal此时是Bird的一个引用，但是编译器是以animal的类型（Animal）来查看有哪些方法的。
即：编译器检查有哪些方法存在，看的是Animal这个类型
执行时究竟执行父类的方法还是子类的方法，看的是Bird这个类型

若animal访问Bird中的方法会产生，ClassCastExceptin(类转型异常)，若一定要执行那就要进行强制类型转换了。见向下转型。

2、方法传参

public class Test {public static void main(String[] args) {Bird bird = new Bird("二哈");feed(bird);}public static void feed(Animal animal) { //向上转型animal.eat();}
}

3、方法返回

public class Test {public static void main(String[] args) {//向上转型Animal animal = findMyAnimal();}public static Animal findMyAnimal() {Bird bird = new Bird("二哈");return bird;}
}

向下类型转换

向下类型转换存在不确定性，比如你是一个图形类，但是不一定是圆形类。对于上面向上转型直接赋值出现的问题，我们可以进行强制类型转换来解决。

 Animal animal = new Bird("二哈"); //向上转型Bird bird = (Bird)animal;  //强制类型转换（向下转型）bird.x; //x可以是Bird当中的方法

这样虽然可以执行不会报错，其实也不是非常靠谱，假如存在下面的代码：

 Animal animal = new Cat("咪咪");Bird bird = (Bird)animal;bird.x; //x为Bird当中的方法

这样的代码运行时会产生ClassCastExceptin(类转型异常)，因为animal其实是Cat对象的一个引用，不能转化为Bird对象的。为了解决这个问题，我们可以在转型前判断animal本质是不是Bird的实例。
因此：向下转型的前提条件是（向下转型）父类已经引用了子类（向下转型后的类型）的对象。

 Animal animal = new Cat("咪咪");if(animal instanceof Bird) {Bird bird = (Bird)animal;bird.x; //x为Bird当中的方法}

instanceof可以判断一个引用是否是某个类的实例，如果是则返回true，这时再进行向下转型就比较安全了。

重写

子类实现父类的同名方法，并且参数的类型完全相同，这种情况称为覆写/重写/覆盖（Override）

重写要注意：
1、static修饰的静态方法不能被重写
2、重写时子类的方法的访问权限必须大于等于父类方法的权限
3、父类方法的权限不能是私有的
4、可以使用@override注解来显性指示

重写和重载的区别：

重载发生在同一个类中，方法名称相同、参数类型或个数不同的方法。对权限没有具体要求
重载在有继承关系的类中，方法名称，返回值类型，参数类型及个数完全相同的方法。并且子类的访问修饰权限必须大于等于子类的访问修饰权限，静态方法和私有方法不能被重写。

class Animal {String name;public Animal(String name) {this.name = name;}public void eat() {System.out.println(this.name + "animal eat");}
}class Cat extends Animal {public Cat(String name) {super(name);}@Overridepublic void eat() {System.out.println(this.name + "cat eat");}
}public class  TestDemo {public static void main(String[] args) {Animal animal = new Cat("花花"); //向上转型animal.eat();}
}

运行这段代码，我们会发现没有子类没有重写父类的方法时，调用的父类的方法eat。当子类重写了父类的方法时，运行出来的是子类的eat方法。为什么呢？底层是这样实现的

当我们查看底层代码时，编译时确实调用的是Animal的eat()方法，运行时是Cat的eat()方法。

运行时多态的原理：
1、如果子类没有重写eat方法时，调用的确实是父类的eat（）
2、子类重写父类的方法时，编译时还是调用父类的方法。运行时确是子类的方法，这个是运行时绑定。
3、在运行时，子类方法的地址覆盖了父类方法的地址。导致调用了子类的方法

这就是动态绑定（运行时绑定）：调用某个类的方法，究竟执行了父类的方法还是子类的方法，要看这个引用究竟指向了父类对象还是子类对象。这个过程是程序运行时决定的，不是编译时。

下图所示过程：