关卡9-面向对象三大特征

1. 封装概述 是面向对象三大特征之一（封装，继承，多态） 是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的

2. 封装原则 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 成员变量private，提供对应的getXxx()/setXxx()方法

3. 封装好处 通过方法来控制成员变量的操作，提高了代码的安全性 把代码用方法进行封装，提高了代码的复用性

4. 2.1 构造方法概述【理解】

   构造方法是一种特殊的方法

5. 作用：创建对象 Student stu = new Student();

6. 格式：

   public class 类名{

   修饰符 类名( 参数 ) {

   }

   }

7. 功能：主要是完成对象数据的初始化

8. 示例代码：

   class Student {
       private String name;
       private int age;
   
       //构造方法
       public Student() {
           System.out.println("无参构造方法");
       }
   
       public void show() {
           System.out.println(name + "," + age);
       }
   }
   /*
       测试类
    */
   public class StudentDemo {
       public static void main(String[] args) {
           //创建对象
           Student s = new Student();
           s.show();
      

   继承：以使的子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法（当两个类有共同的属性和方法，就可以用继承，或者说一个类和一个类中有包含关系，就可以使用继承），java中类只支持单继承，也就是只能用extends继承一个，不能多次继承，但是可以多层继承。

9. 

    

    继承变量的特点
       1，先在子类局部找（即子类方法中找）
       2，在子类成员范围中找
       3，在父类中找
       4，都没有就报错（不考虑父类的父类）

10. 1.2 继承的好处和弊端（理解）

    • 继承好处

      • 提高了代码的复用性(多个类相同的成员可以放到同一个类中)

      • 提高了代码的维护性(如果方法的代码需要修改，修改一处即可)

    • 继承弊端

      • 继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

    • 继承的应用场景：

      • 使用继承，需要考虑类与类之间是否存在is..a的关系，不能盲目使用继承

        • is..a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类

          2.1 继承中变量的访问特点（掌握）

          在子类方法中访问一个变量，采用的是就近原则。

        • 子类局部范围找

        • 子类成员范围找

        • 父类成员范围找

        • 如果都没有就报错(不考虑父亲的父亲…)

多态:

 

1.1多态的概述（记忆）

• 什么是多态

  同一个对象，在不同时刻表现出来的不同形态

• 多态的前提

  • 要有继承或实现关系

  • 要有方法的重写

  • 要有父类引用指向子类对象

1.2多态中的成员访问特点（记忆）

• 成员访问特点

  • 成员变量

    编译看父类，运行看父类

  • 成员方法

    编译看父类，运行看子类

1.3多态的好处和弊端（记忆）

• 好处

  提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作

• 弊端

  不能使用子类的特有成员

1.4多态中的转型（应用）

• 向上转型

  父类引用指向子类对象就是向上转型

• 向下转型

  格式：子类型 对象名 = (子类型)父类引用;

• 

  多态的案例（应用）

• 案例需求

  请采用多态的思想实现猫和狗的案例，并在测试类中进行测试

• 代码实现

  • 动物类

  • public class Animal {
        private String name;
        private int age;
    
        public Animal() {
        }
    
        public Animal(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public void eat() {
            System.out.println("动物吃东西");
        }
    }

    //动物类
    public class Cat extends Animal {
    
        public Cat() {
        }
    
        public Cat(String name, int age) {
            super(name, age);
        }
    
        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
    }//狗类
    public class Dog extends Animal {
    
        public Dog() {
        }
    
        public Dog(String name, int age) {
            super(name, age);
        }
    
        @Override
        public void eat() {
            System.out.println("狗吃骨头");
        }
    }//测试类
    public class AnimalDemo {
        public static void main(String[] args) {
            //创建猫类对象进行测试
            Animal a = new Cat();
            a.setName("加菲");
            a.setAge(5);
            System.out.println(a.getName() + "," + a.getAge());
            a.eat();
    
            a = new Cat("加菲", 5);
            System.out.println(a.getName() + "," + a.getAge());
            a.eat();
        }
    }