java面向对象的三大特性

一.封装（private）

1.概念：尽可能隐藏对象的内部实现细节，控制对象的修改及访问的权限。

2.访问修饰符：private （可将属性修饰为私有，仅本类可见）

3公共访问方法 ：因为不能直接访问，所以需要提供 公共访问方法间接访问

4.访问规则：

赋值：setXXX() //使用方法参数实现赋值

取值：getXXX() //使用方法返回值实现取值

5.数据过滤：可以在set方法中添加条件，进行数据的筛选

public class Test {
    private int stuAge;//定义私有成员属性
    private int stuTel;

    public int getStuAge() {//定义stuAge的获取方法
        return stuAge;
    }

    public void setStuAge(int stuAge) {//定义stuAge的赋值方法
        this.stuAge = stuAge;
    }

    public int getStuTel() {//定义stuTel的获取方法
        return stuTel;
    }

    public void setStuTel(int stuTel) {//定义stuTel的赋值方法
        this.stuTel = stuTel;
    }
}

二.继承（extends）

1.概念：一个类从另一个类中获取方法和属性的过程。

2.语法：class 子类 extends 父类{ } //定义子类时，显示继承父类

3.特点：Java为单继承，一个类只能有一个直接父类，但可以多级继承，属性和方法逐级叠加。

4. 不可继承的： 构造方法，private修饰的属性和方法，父子类不在同一个package中时，default修饰的属性和方法

class fatherTest{//父类
    public void run(String str){//定义父类方法
    System.out.println("我是父类方法");
}
}
class sonTest extend fatherTest{//子类 且继承父类
    public static void main(String[] args){
    super.run();//调用父类方法
}
}

三.程序中的多态

1.概念：父类引用指向子类对象，从而产生多种形态。

注意： 

二者具有直接或间接的继承关系时，父类引用可指向子类对象，即形成多态。

父类引用仅可调用父类所声明的属性和方法，不可调用子类独有的属性和方法。

2.向上转型（装箱）

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();//向上转型
        animal.eat();
    }
}
class Animal{
    public void eat(){//定义eat方法
        System.out.println("动物在吃");
    }
}
class Dog extends Animal{
    public void eat(){//重写父类中的eat方法
        System.out.println("狗在吃");
    }
}

程序运行结果：

狗在吃

注意：

父类引用中保存真实子类对象， 称为向上转型（即多态核心概念）。

仅可调用Animal中所声明的属性和方法。

3.向下转型（拆箱）

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();//向上转型
        animal.eat();//在编译时只可以调用Animal
        Dog dog = (Dog) animal;//向下转型
        dog.sleep();//调用子类特有的方法
    }
}
class Animal{
    public void eat(){//定义eat方法
        System.out.println("动物在吃");
    }
}
class Dog extends Animal{
    public void eat(){//重写父类中的eat方法
        System.out.println("狗在吃");
    }
    public void sleep(){//定义子类特有方法
        System.out.println("狗在睡");
    }
}

程序运行结果：

狗在吃

狗在睡

注意：

将父类引用中的真实子类对象，强转回子类本身类型，称为向下转型。

只有转换回子类真实类型，才可调用子类独有的属性和方法。

类型转换异常

向下转型时，如果父类引用中的子类对象类型和目标类型不匹配，则会发生类型转换异常。

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();//向上转型
        Cat cat = (Cat) animal;//会引发类型转换异常
    }
}
class Animal{
    public void eat(){//定义eat方法
        System.out.println("动物在吃");
    }
}
class Dog extends Animal{
    public void eat(){//重写父类中的eat方法
        System.out.println("狗在吃");
    }
    public void sleep(){//定义子类特有方法
        System.out.println("狗在睡");
    }
}
class Cat extends Animal{
    public void eat(){//重写父类中的eat方法
        System.out.println("猫在吃");
    }
    public void sleep(){//定义子类特有方法
        System.out.println("猫在睡");
    }
}

4.instanceof关键字

向下转型前，应判断引用中的对象真实类型，保证类型转换的正确性。

语法：父类引用 instanceof 类型 //返回boolean类型结果

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();//向上转型
        if(animal instanceof Dog){//判断判断引用中的对象是不是Dog类
            Dog dog = (Dog) animal;
            dog.eat();
        }else if(animal instanceof Cat){//判断引用中的对象手机不是Cat类
            Cat cat = (Cat) animal;
            cat.eat();
        }
    }
}

注意：

向下转型前，应判断引用中的对象真实类型，保证类型转换的正确性。

5.应用场景：

使用父类作为方法形参。

使用父类作为方法返回值，