Java面向对象03：三大特性

封装

属性私有，get/set

• 程序设计追求”高内聚，低耦合“：高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合就是仅暴露少量的方法给外部使用
• 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏

        /*
1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节 
3. 统一接口
4. 增强系统可维护性
 */
public class Hello {
    public static void main(String[] args) {
        Student xm = new Student();
//        xm.name = "小明";  //name属性是privat私有类型，因此对象不能直接通过属性名调用
        xm.setName("小明");  //只能通过set方法进行赋值
        System.out.println(xm.getName());  //只能通过get方法获取值
        xm.setGender(‘男‘);
        System.out.println(xm.getGender());
    }
}

class Student{
    private String name;
    private char gender;

    public String getName() {  //定义私有属性专用的赋值和调用方法，快捷键alt + insert
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        if (gender == ‘男‘ | gender == ‘女‘){  //私有属性的set方法可以定义一些规则，避免不合法的信息输入
            this.gender = gender;
        }
        else{
            this.gender = ‘无‘;
        }
    }
}

    

继承

继承的本质是对某一批类的抽象，是类与类之间的一种关系，子类扩展父类，使用关键字extends表示

Java中类只有单继承，没有多继承，而所有类都直接或间接继承Object类

        /*
四种修饰符：
1. public，需要被继承时使用
2. private，一般属性会用到私有
3. protected
4. default，默认不写
 */
public class Father {
    public static void main(String[] args) {
        Son xm = new Son();
        xm.say();  //父类的say()方法子类对象可以直接调用
//        xm.money;  //父类的私有属性，子类无法直接访问
        System.out.println(xm.getMoney());  //私有属性通过get方法调用
    }
    private int money = 1;
    public int getMoney() {
        return money;
    }
    public void say() {
        System.out.println("可以说话");
    }
}

class Son extends Father{
    //子类继承父类的所有方法
}

    

super关键字

        public class Hello {
    public static void main(String[] args) {
        Son son = new Son();
        son.print("ty");
    }
}

class Father {
    Father(){
        System.out.println("父类的无参构造器");
    }
    Father(String name){
        System.out.println("父类的有参构造器");
    }
    protected String name = "tyy";
}

class Son extends Father {
    Son (){
//        super();  //隐藏代码：子类构造器默认先调用父类的无参构造器，再执行子类的构造器。同理this()调用本类的构造器
        System.out.println("子类的无参构造器");
//        super(name);  //如果父类没有无参构造器，则必须显式调用父类的有参构造器，且必须写在第一行，否则报错。此时super和this无法同时调用各自的构造函数，因为都需要放在第一行，所以就算不需要无参构造器，也要写出来
    }
    protected  String name = "tty";
    public void print(String name){
        System.out.println(name);  //ty
        System.out.println(this.name);  //tty，this关键字特指本类的对象
        System.out.println(super.name);  //tyy，如果子类和父类的属性或方法重名，则通过super关键字来特指父类对象的引用
    }
}

    

方法重写

重写的前提是有继承关系，子类只能重写父类的非静态、非常量、非私有方法

• 方法名必须相同
• 参数列表必须相同
• 修饰符：范围可以扩大但不能缩小（private --> default --> protected --> public）
• 抛出的异常：范围可以缩小但不能扩大

        public class Hello {
    public static void main(String[] args) {
        Father f = new Son();  //父类的引用f可以指向子类，子类的引用也可以指向父类。对象能调用哪些方法，只和左边声明对象引用变量的类名有关！
        Son s = new Son();
        f.test();  //父类的静态test方法
        s.test();  //子类的静态test方法
    }
}

class Father {
//    public static void test(){
//        System.out.println("父类的静态test方法");
//    }
    public void test(){
        System.out.println("父类的非静态test方法");
    }
}

class Son extends Father {
//    public static void test(){  //当子类重写静态方法时，因为静态方法是类方法，一开始就加载了，所以声明类型为父类的引用变量f调用的仍是父类的方法，因此无法重写
//        System.out.println("子类的静态test方法");
//    }
      @Override
      public void test() {  //当重写非静态方法时，因为非静态方法是对象的方法，虽然f的声明类型为父类，但其实际类型是子类，所以f调用是子类的方法，达到了重写的目的。快捷键alt + insert
          System.out.println("子类的非静态test方法");  //这涉及到Java类的多态性，见后！
    }
}

    

多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。多态是方法的多态，属性没有多态性

一个对象的实际类型是确定的，但可以指向对象的引用类型有很多，父类引用可以指向子类

多态存在的条件

• 有继承关系

• 子类需要重写父类方法

• 父类引用指向子类对象

instanceof关键字

• instanceof关键字判断对象是否属于某个类

类型转换

• 父类引用变量想要调用子类独有的方法，需要强制转换为子类
• 子类也可以转换为父类，但是会丢失一些自己的方法

        public class Hello {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的，但可以指向对象的引用类型有很多，父类引用可以指向子类
        Father s1 = new Son();
        Son s2 = new Son();
        s1.print();  //子类重写了父类的方法，调用子类的方法
        s2.print();
//        s1.own();  //对象能调用哪些方法，只和左边声明对象引用变量的类名有关。s1声明为父类，所以无法调用子类自己的方法
        ((Son)s1).own();  //强制将s1转换为Son类型，就可以调用子类的方法
        s2.own();
        Father s3 = s2;
//        s3.own();  //子类转换为父类后，丢失了子类本身的方法
        System.out.println(s1 instanceof Father);  //true，instanceof关键字判断对象是否属于某个类
        System.out.println(s1 instanceof Son);  //true
        System.out.println(s2 instanceof Father);  //true
        System.out.println(s2 instanceof Son);  //true

    }
}

class Father {
    public void print(){
        System.out.println("Father的方法");
    }
}

class Son extends Father {
    @Override
    public void print() {
        System.out.println("Son的方法");
    }
    public void own(){
        System.out.println("子类自己的方法");
    }
}

    

原文：https://www.cnblogs.com/taoyuann/p/15237950.html