WGL的day07

封装

• 该露的露,该藏的藏

  • 我们的程序设计要追求"高内聚",“低耦合”.高内聚就是类的内部数据操作细节自己完成,不允许干涉;低耦合就是仅暴露少量方法给外部使用

• 封装(数据的隐藏)

  • 通常,应禁止直接访问一个对象中的数据的实际表示,而应通过操作接口来访问,这称为信息隐藏

• 封装代码

package demo3;

public class Pet {
   private String name;    //private 本类中私有
   private int age;
   private String sex;

    public Pet(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public Pet() {            
    }

    public String getName() {           //ALT+Ins自动生成get,set方法
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String toString() {
        return "Pet{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}

package demo3;

public class Application {
    public static void main(String[] args) {
        Pet dog = new Pet();
        dog.setAge(5);
        System.out.println(dog.getAge());
        dog.setName("大佬");
        System.out.println(dog.getName());
        dog.setSex("公");
        System.out.println(dog.getSex());
        System.out.println(dog);
        System.out.println(dog.toString());
        Pet a1 = new Pet("大大",6,"母");
        System.out.println(a1.toString());
        System.out.println(a1);
    }
}

封装的意义

1.提高程序的安全性,保护数据

2.隐藏代码的实现细节

3.统一接口

4.系统可维护增加了

继承

• 继承的本质是对某一批类的抽象,从而实现对现实世界更好地建模
• extands的意思是"扩展",子类是父类的扩展
• JAVA中类只有单继承,没有多继承

1. 继承是类和类之间的一种关系,除此之外,类和类之间的关系还有依赖,组合,聚合等
2. 继承关系的两个类,一个为子类(派生类),一个为父类(基类),子类继承父类,使用关键字extands来表示
3. 子类和父类之间,从意义上讲应该具有"is a"的关系

• object类
• super - this
• 方法重写

super和this的区别

super.name 指代父类Person里的name

this.name 指代本类中的name

方法的重写

• 静态方法和非静态方法区别很大

• 静态方法 : 方法的调用只和左边,定义的数据类型有关

super注意点:

1. super调用父类的构造方法，必须在构造方法的第一个2. super必须只能出现在子类的方法或者构造方法中!3. super和 this不能同时调用构造方法!

this:

代表的对象不同:

this:本身调用者这个对象super:代表父类 对象的应用前提

this:没哟继承也可以使用

super:只能在继承条件才可以使用构造方法

this() ; 本类的构造

super():父类的构造!

重写:需要有继承关系，子类重写父类的方法!

1.方法名必须相同

2.参数列表列表必须相同

3.修饰符:范围可以扩大但不能缩小:

public>Protected>Default>private

4.抛出的异常:范围，可以被缩小，但不能扩大: ClassNotFoundException --> Exception(大)

重写，子类的方法和父类必要一-致; 方法体不同!

为什么需要重写:

1.父类的功能，子类不一-定需要。或者不一-定满足 !

Alt + Insert ;override;

多态

◆即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

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

多态存在的条件:

◆有继承关系

◆子类重写父类方法

◆父类引用指向子类对象

注意:多态是方法的多态，属性没有多态性。

◆instanceof

总结

1. 多态是方法的多态,属性没有多态
2. 父类和子类,有关系 类型转换异常 ClassCastException!
3. 存在条件: 继承关系,方法需要重写,父类引用指向子类对象! Father f1 = new Son();

• static 方法,属于类,他不属于实例
• final 常量
• private 方法;

instanceof(判断是否是父子关系)

package demo8;

import javax.print.DocFlavor;

public class Application {


    public static void main(String[] args) {
        //对象能执行的方法主要看左边的类型
        Student a1 = new Student();
        Person a2 = new Student();
        Object a3 = new Student();

       a1.eat();
       a1.run();   //看左边类 Student
       a2.run();   //Person
           //**必须转换**
       ((Student) a2).eat();

        //Object> String
        //Object> Person >Teacher
        //Object> Person > Student
        Object object = new Student();
        System.out.println(object instanceof Student); //true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false
        System.out.println("===================================");
        Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Student);//false
       // System.out.println(person instanceof String);   //编译报错,person和String无关系
        System.out.println("===================================");
        Student student = new Student();
        System.out.println(student instanceof Student); //true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof Teacher); //编译报错,student和Teeacher无关系
        //System.out.println(student instanceof String);  //编译报错,student和String无关系
    }
}

1. 父类的引用指向子类的对象 Person person = student;

2. 把子类转换为父类,向上转型

3. 把父类转换为子类,向下转型 : 强制转换

4. 方便方法的调用,减少重复的代码!

acher); //编译报错,student和Teeacher无关系
//System.out.println(student instanceof String); //编译报错,student和String无关系
}
}

1. 父类的引用指向子类的对象 Person person = student;

2. 把子类转换为父类,向上转型

3. 把父类转换为子类,向下转型 : 强制转换

4. 方便方法的调用,减少重复的代码!