封装继承多态

面向对象的三大特性

一继承继承是类和类之间的一种关系

继承的作用

1 子类可以调用父类的方法，代码如下：

class BaseClass{

public double weight;

public void info() {

System.out.println("我的体重是"+weight+"千克");

}

public class ExtendsDemo001 extends BaseClass {

public static void main(String[] args) {

//创建ExtendsDemo001对象

ExtendsDemo001 ed = new ExtendsDemo001();

//ExtendsDemo001本身没有weight属性，但是ExtendsDemo001的父类有weight属性，也可以访问ExtendsDemo001对象的属性

ed.weight = 56;

//调用ExtendsDemo001对象的info()方法

ed.info();

}

2 子类可以调用父类的构造器

class Base{

public double size;

public String name;

public Base(double size, String name){

this.size=size;

this.name=name;

}

public class Sub extends Base{

public String color;

public Sub(double size, String name, String color){

//在子类构造器中调用父类构造器，使用super调用来实现

super(size,name);

this.color = color;

}

public static void main(String[] args) {

Sub s = new Sub(5.6,"测试对象","红色");

System.out.println(s.size+"------"+s.name+"------"+s.color);

}

打印结果为：5.6------测试对象------红色

3 子类的重写（重写只能写在子类中）

1 为什么子类会存在重写现象？

父类的功能子类不一定需要或者不一定满足

重写办法：alt+insert然后选中overrid

class Bird{

//Bird类的fly()方法

private void fly(){

System.out.println("我要在天空中飞翔");

}

public class OcerrideTest extends Bird{

//重写Bird类的fly()方法

public void fly(){

System.out.println("我只能在地上奔跑");

}

public static void main(String[] args) {

//创建OcerrideTest对象

OcerrideTest ot = new OcerrideTest();

ot.fly();

}

打印结果为：我只能在地上奔跑

重写的注意事项

需要有继承关系子类重写父类的方法

1 方法名必须相同

2 参数列表必须相同

3修饰符：范围可以扩大不能缩小比如（父类是private 可以变成public）

修饰符的大小关系：public>protected>default>private

4抛出的异常可以被缩小但不能被扩大。

比如（classNotFoundExpection（小））->Expection（大）

重写：子类的方法必须要和父类的方法保持一致，方法体不同

注意：

若想调用父类中的fly()方法，则只需在子类中fly()方法中加上如下代码即可：

super.fly();

二封装（属性私有，get/set）

指的是将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，而是通过该类所提供的方法来实现对内部信息的操作和访问。

程序：

public class Person {

public static void main(String[] args) {

Person p = new Person();

p.setAge(10);

System.out.println(p.getAge());

}

//将属性使用private修饰，将这些属性私有化

private String name;

private int age;

//提供方法来操作name属性

public void setName(String name) {

//对姓名执行合理的校验

if(name.length() > 6 || name.length() < 2){

System.out.println("您的姓名不符合要求");

}else{

this.name = name;

}

public String getName() {

return this.name;

}

//提供方法来操作age属性

public void setAge(int age) {

if(age>100 || age<0){

System.out.println("您的年龄必须要在0~100之间");

}else{

this.age = age;

}

public int getAge() {

return this.age;

}

运行结果为：10

封装的意义

1 提高程序的安全性，保护数据

2 隐藏代码的实现细节

3统一接口

4系统的可维护性增加了

三多态

一个是编译时类型，一个是运行时类型。编译时的类型由声明该变量时使用的类型决定，运行时的类型由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一致，就会出现所谓的多态（Polymorphism）

package demo1;
public class  Person{
    public void run(){
        System.out.println("run");
    }
    public void sleep(){
        System.out.println("sleep");
    }
}

package demo1;
public class Student extends Person {
    public void run(){
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }

}

package demo1;
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();// 编译时类型和运行时类型一致 不会产生多态
        Person p1 = new Student();//运行时类型是person，编译时类型是student类，存在不同，产生多态
        //本来应该执行的Person run 方法 但是却执行了student的run方法，这就是多态
        s1.run();
        p1.run();//结果是run
        p1.sleep();//结果sleep
        //p1.eat(); 编译错误 Person类中不存在eat方法
    }
}

在程序中调用方法时，类型中没有这个方法就调用不了，子类和父类都有这个方法的情况下，只要子类没有重写这个方法，就调用父类，如果重写，调用子类重写后的方法

多态存在的条件

有继承关系

子类重写父类方法

父类引用指向子类对象

posted @ 2021-01-17 16:00 想变成葡萄的橙子阅读(33) 评论(0) 收藏举报

刷新页面返回顶部

封装 继承 多态

公告

封装继承多态