1.  访问修饰符

1.1  基本介绍

java 提供四种访问控制修饰符号，用于控制方法和属性(成员变量)的访问权限（范围）:

1. 公开级别:用public 修饰,对外公开
2. 受保护级别:用protected修饰,对子类和同一个包中的类公开
3. 默认级别:没有修饰符号,向同一个包的类公开.
4. 私有级别:用private修饰,只有类本身可以访问,不对外公开.

1.2  4种访问修饰符的访问范围

 1.3  使用的注意事项

• 修饰符可以用来修饰类中的属性，成员方法以及类
• 只有默认的和public才能修饰类!并且遵循上述访问权限的特点。
• 成员方法的访问规则和属性完全一样.

 2.  面向对象编程三大特征

 2.1  基本介绍

面向对象编程有三大特征：封装、继承和多态。

2.2  封装介绍

        封装(encapsulation)就是把抽象出的数据[属性]和对数据的操作[方法]封装在一起,数据被保护在内部,程序的其它部分只有通过被授权的操作[方法],才能对数据进行操作。

2.3  封装的理解和好处 

• 隐藏实现细节
• 可以对数据进行验证，保证安全合理 

2.4  封装的实现步骤 (三步) 

1. 将属性进行私有化private 【不能直接修改属性】
2. 提供一个公共的(public)set方法，用于对属性判断并赋值
3. 提供一个公共的(public)get方法，用于获取属性的值public 数据类型 

 2.5  如何使用封装

//    使用private修饰类中成员。private的作用: 外界无法访问，但是本类可以调用。
public class Teacher{
    //老师类拥有的属性。
    String name;//姓名属性---成员变量
    private int age; //年龄属性

    public void setAge(int a){
        if(a<=0){
            System.out.println("年龄不合法");
        }else {
            age = a;
        }
    }

    public int getAge(){
        return age;
    }

    public void teach(){
        System.out.println(name+"老师正在授课");
        info();
    }
    public void info(){
        System.out.println("姓名："+name+"年龄："+age);
    }
}

3.  面向对象编程-继承

3.1 什么是继承？

继承可以使得子类具有父类的属性和方法或者重新定义、追加属性和方法等。

如果某类B“继承”另某类A，就把这个B称为“A的子类或派生类（subclass）”，而把类A称为“B的父类”也可以称为“A是B的超类或基类（superclass）

3.2  为什么使用继承

1.提高代码的可重用性
2.起到扩展功能的作用！
没有继承时，会出现什么情况？
需求：动物园引进新品种  Dog，模拟 id  age  name 属性。动物园引进新的动物 Cat.同样有 id  age  name 属性
忽然有一天，老板说id不好  要改名  aid 。两个动物很好改，如果有一万个动物，能改很麻烦，
改完运行三个月后，老板又说了，还是id好，改回来！程序员们苦逼的改改改。
又改完了，运行三个月后，老板又说了，还是aid好，再改回来！。。。程序员崩溃的！

3.3  继承的基本语法

 3.4  快速入门

 4.  super关键字

4.1  基本介绍

super代表父类的引用，用于访问父类的属性、方法、构造器

4.2  基本语法 

4.3  super 给编程带来的便利/细节

 4.4  super 和 this 的比较

5.  方法重写/覆盖(override) 

5.1  基本介绍

        简单的说:方法覆盖(重写)就是子类有一个方法,和父类的某个方法的名称、返回类型、参数一样,那么我们就说子类的这个方法覆盖了父类的方法

5.2  重写的特点

        子类中的方法名与父类中方法名相同，参数相同，返回类型也要相同。访问修饰符不能小于父类的访问修饰符，抛出的异常不能大于父类的。

5.3  为什么需要重写

        因为父类中的功能无法满足子类需求时。才需要重写。

        重写后创建子类对象后调用得到方法应该时重写后的方法。

 5.4  注意事项和使用细节

        方法重写也叫方法覆盖，需要满足下面的条件：

6.  面向对象编程-多态 

6.1  什么是多态

多态是OOP面向对象编程的第三个特点。表现为：对象多态、行为多态。 

多态性是允许你将父类引用设置成为一个或更多的他的子对象相等的技术，赋值之后，父类引用就可以根据当前赋值给它的子对象的特性以不同的方式运作。

6.2  多态的表现形式

第一种: 继承多态.  父类 对象名=new 子类();
public class Animal {

    public void eat(){
        System.out.println("动物吃东西");
    }
}
public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal d=new Dog();
        Animal c=new Cat(); //父类的引入可以指向多个子类的对象。这种现象就是多态.必须存在继承关系
        d.eat(); //狗吃肉
        c.eat(); //猫吃鱼
        //父类对象根据赋值的子类对象，而表现出不同的行为。
    }
}
第二种: 接口多态   接口名 对象名=new 接口的实现类();

6.3  为什么使用多态？

        动物园召开全作动物大会，需要一个管理员中途给动物喂食物，请完成以下功能

        饲养员:喂养动物功能函数

        A 有一个猫咪需要被喂养

        B 有一个狗儿需要被喂养

        C 有一个猪猪需要被喂养

        你发现问题了吗?

        如果这时动物园里引进了新物种---猫咪。 要求饲养员也可以喂养猫咪。  

public class Test {
    public static void main(String[] args) {
        Feeder f=new Feeder();//创建一个饲养员对象
        Dog d=new Dog();
        f.feed(d); //后期:一个类依赖另一个类。

        Cat c=new Cat();
        f.feed(c);
    }
}
class Feeder{//饲养员类
    //喂养的功能--狗
    public void feed(Dog d){
        d.eat();
    }
    //喂养的功能--猫
    public void feed(Cat c){
        c.eat();
    }

}
class Dog{
    public void eat(){
        System.out.println("狗吃骨头");
    }
}
class Cat{
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

        思考: 每次引进一个新物种，都需要修改饲养员的代码。代码的复用性不高，而且不利于代码维护。 饲养员类与新增的物种产生高耦合。 我们如果要解决这种耦合度。 可以使用多态。  

 

 6.4  多态注意事项和细节讨论

        多态的前提是：两个对象(类)存在继承关系

        多态的向上转型

1. 本质:  父类的引用指向了子类的对象
2. 语法:  父类类型引用名 =new 子类类型();
3. 特点:  编译类型看左边，运行类型看右边。可以调用父类中的所有成员(需遵守访问权限)。不能调用子类中特有成员。最终运行效果看子类的具体实现!

Dog中的代码：

public class Dog extends Animal {
    // eat
    @Override
    public void eat(){
        System.out.println("我是一只狗，我喜欢吃奥里给！！！");
    }
    // 看家 watchDoor()
    public  void watchDoor(){
        System.out.println("狗会看门！！！");
    }
}

test类：

Animal animal = new Dog();// 向上转型
 // dog 赋值给Animal
animal.eat();
animal.watchDoor(); // 报错

 

        多态的向下转型

1. 语法:  子类类型  引用名 = (子类类型)  父类引用;
2. 只能强转父类的引用，不能强转父类的对象
3. 要求父类的引用必须指向的是当前目标类型的对象
4. 当向下转型后，可以调用子类类型中所有的成员

public static void main(String[] args) {
    // Dog
    Animal a = new Dog();
    // ⼦类引⽤⽗类对象
    Dog dog1 = (Dog) a;
    // 向下转型 可以调用子类里面方法   属性
    dog1.watchDoor();
    Cat cat = (Cat) a;

}

此时可以调用子类对象中的方法和属性