封装继承多态

最新推荐文章于 2023-05-16 01:02:03 发布

原创最新推荐文章于 2023-05-16 01:02:03 发布 · 115 阅读

0 ·

CC 4.0 BY-SA版权

封装

高内聚，低耦合。
属性私有（private）, get/set。

封装的意义：

提高程序的安全性，保护数据。
隐藏代码的实现细节。
统一接口。
增加系统可维护性。

public class Student(){
    
    //定义私有属性
    private String name;
    private age int;
    
    //get
    public String getName(){
        return this.name;
    }
    public String getAge(){
        return this.age;
    }
    
    
    //set
    public void setName(String name){
        this.name = name;
    }    
    public void setName(int age){
        if(age > 120 || age < 0){
            System.out.println("输入的年龄不合法!");
            this.age = 0;
        }else{
            this.age = age;
        }
    }
}


//方法类
public class Application{
    public static void main(String[] args) {
        
        Student stu = new Student();
        
        stu.setName = "小美女";
        System.out.println(stu.getName);
    }
}

继承

继承的本质是对某一批类的抽象。
extands的意思是 “扩展” 。子类是父类的扩展。
JAVA中只有单继承，没有多继承。
继承是类和类之间的关系。其他关系还有依赖、组合、聚合等等。

//人 类    父类（基类）
public class Person(){
    
    private int money = 10_0000_0000;
    
    public void say(){
        System.out.println("说了一句话！");
    }
    
    public int getMoney(){
        return money;
    }
}

//学生类继承人类    子类（派生类）
public class Student extends Person(){
    Person per = new Person();
    System.out.println(per.getMoney);
    
}

//老师类继承人类    子类（派生类）
public class Teacher extends Person(){
    
}

Object类

在Java中，所有的类都直接或间接继承object。

super

注意点：
- super调用父类的构造方法，必须在构造方法的第一行。
- super只能出现在子类的方法或构造方法中。
- super和this不能同时调用构造方法。
super 和 this ：
- 代表对象不同：this指本身调用者这个对象，，super指代表父类对象的引用。
- 前提：this在没有继承也可以使用，，super只能在继承条件下才能使用。
- 构造方法的区别：this()本类的构造，，super是父类的构造。

//父类（基类）
public class Person(){
    protected String name = "李白";
    
    //私有的东西不能被继承
    private int age = 31;
    
}

//子类（派生类）
public class Student extends Person(){
    private String name = "张飞;
        
    public void test(String name){
        System.out.println(name);           //刘备
        System.out.println(this.name);      //张飞
        System.out.println(super.name);     //李白
    }  
}

public class Application(){
    public static void main(String[] args) {
        Student stu = new Student();
        stu.test("刘备");
    }
}

方法的重写（override）

重写都是方法的重写，和属性无关。
重写需要有继承关系，子类重写父类方法。
方法名必须相同。
参数列表必须相同。
修饰符：范围可以扩大，不能缩小（ public > Protected > Default > private ）。
抛出的异常：范围可以被缩小，不能扩大（ ClassNotFountExcation（小） --> Excation(大) ）。

public class B(){
   public void test(){
        System.out.println("B=>test");  
   }
}

public class A extends B(){
    public void test(){
        System.out.println("A=>test");  
    }
}


public class Application(){
    public static void main(String[] args) {
        
        A a = new A();
        a.test();       //A
        
        //父类的引用指向了子类
        B b = new A();
        b.test();       //B
    }
}

多态

即一种方法可以根据发送对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向其他的引用类型。

注意事项：

1.多态是方法的多态，属性没有多态。

2.类型转换需要有联系。

3.继承关系，方法要重写，父类的引用指向子类。

不能重写的方法：

static 方法，属于类，不属于实例。
final 常量；
private 方法。

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


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


public class Application{
    public static void main(String[] args) {
        
        Student s1 = new Student();
    
        //父类的引用指向子类，不能调用子类独有的方法
        Person s2 = new Studnet();
    
        Object s3 = new Student();
    
        //对象能执行哪些方法，主要看对象左边的类型。
        s2.run();   //子类重写了父类的方法，执行子类的方法
        s1.run();
        
        s2.eat();   //程序报错
        ((Student) s2).eat();   //类型转换
        
    }
}