Java 面向对象 封装、继承、覆写、多态

 封装

        封装即把所有组成部分组合到一起,还可以通过权限控制修饰符将数据隐藏起来,可以控制用户对类数据的修改程度. 适当的封装可以让代码更容易理解,易于维护,更提高了代码的安全性

package

        package : 引入包机制,可以解决命名冲突问题,完整的类名是带有包名的

        package 是规定编译之后的class文件的放置目录,不是java文件的放置目录

import

        import : 导入其他类,使当前类中可以直接使用该类,而不用编写类全名

        可以有多个,写在package语句之下class语句之上

import 包名.类名;//某个包下的某个类 
import 包名.*;//某个包下的所有类

权限控制

访问控制符	同一类中	同一包中	同一子类中	其他
public	true	true	true	true
protected	true	true	true	false
default	true	true	false	false
private	true	false	false	false

继承

        从一个已有的类中衍生出新的类,包含父类的特征,还可以新增特有的属性

        Java中只支持单继承,一个类只能有一个父类,并且继承是可以传递的, 但是一个类可以有很多子类. 如果一个类没有显示继承另一个类,则该类默认继承的是java.lang.Object, Object是java提供的根类,所有类都会直接或者间接继承Object 

        继承的好处是代码复用, 最大的功能在于方法覆写

class 父类名{
}
class 类名 extends 父类名{
}

super

        在Java中，super表示超类，当子类需要引用父类的字段时,可以使用super.名

        用于区分子类和父类同名的属性和方法, 以及在子类构造方法中,重载调用父类的构造方法

public class Super_01 {
    public static void main(String[] args) {
    Sub sub = new Sub();
    sub.test();
    }
}

class Sup {
    int age = 19;
    String name = "张三";

    public void m1() {
    System.out.println("父类m1");
    }

    public void m2() {
    System.out.println("父类m2");
    }
}

class Sub extends Sup {
    int age = 12;

    public void m1() {
    System.out.println("子类m1");
    }
    public void test(){
    System.out.println(age);
    System.out.println(super.age);
    System.out.println(name);
    m1();
    super.m1();
    m2();
    }
}

class Sup1{
public Sup1(int i){
    super();
    System.out.println("父类构造方法");
    }
}
class Sub1 extends Sup1{
public Sub1(){
//在子类构造方法中,如果第一行没有写super()或this()那么默认有个super()去调用父类无参构造
//如果父类没有无参构造,则子类构造方法中,必须在第一行手写super(xxx)进行调用
super(2);
System.outprintln("子类构造方法");
    }
}

覆写

         Override 方法覆写,子类覆写父类的方法(即前提是继承关系),当父类功能无法满足子类需求的时候,需要对父类功能进行重写

        要求: 1.方法名、参数列表、返回值 必须相同. 2.不能比原方法有更低的访问权限,权限控制必须大于等于原方法 3. 不能比原方法有更宽泛的异常,异常要小于等于原方法

class Sup{
    public void m1(){
        System.out.println("123");
    }
    public String m2(int a){
        return "覆写";
    }
}
class Sub{
    @Override    //只是注解
    public void m1(){
    }    
    @Override
    public String m2(int a){
        return "@Override";    
    }
}

多态

        多态(polymorphic) : 相同功能具有多种表现形态,不同的对象有不同的状态

        即一个对象在不同条件下所表现的不同形式

        体现为父类引用指向子类对象, 使用父类类型创建的引用类型变量,可以找到子类对象

        父类 变量名 =  new 子类();

        多态中, 调用父类的非成员方法; 子类和父类存在同名的成员变量时，访问的是父类的成员变量; 存在同名的成员方法时，访问的是子类中覆写的方法;  不能访问子类独有的方法(可强制转换类型为子类进行调用)

        优点是降低耦合度,扩展性、替换性、维护性、灵活性增强, 缺点是丢失子类特有的属性

        多态的几种形式

// 1 直接多态
Sup sup = new Sub();
// 2 实参形参多态(参数列表使用父类声明局部变量,调用时传入子类对象)
m1(new Sub());
// 3 返回值多态,返回值类型使用父类声明,但是却return 子类对象
Sup result = m2();
// 4 隐式多态
//

 Instanceof 

        instanceof, 判断某个对象是否由每个类实例化而来, 可以防止向下转型出现错误

    public static void main(String[] args) {
    Sup sup = new Sub();
    // Sup sup = new Sup();
    Sub sub = null;
    System.out.println(sup instanceof Sub);
    if (sup instanceof Sub) {
    sub = (Sub) sup;
    }
    System.out.println(sub);
    }