博客

Java学习20

封装

该露的露，该藏的藏

• 
  程序设计追求“
  
  高内聚，低耦合
  
  ”。高内聚：类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量方法给外部使用。
  

封装（数据的隐藏）

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

重点：属性私有，get/set

**alt + insert 可以自动生成方法 **

get用this，set用return。

封装中还可进行条件判断

private String name;//名字
    private int id;//学号
    private char sex;//性别
    //get  获得这个数据
    public String getName(){
        return this.name;
    }
    //set  给这个数据设置值
    public void setName(String name){
        this.name=name;
    }public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>120||age<0){//不合法
            this.age= 1;
        }
        else{
            this.age = age;
        }

    }

public class Application {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.setName("xx");
        s1.setAge(99);
        System.out.println("Name"+s1.getName());
        System.out.println("Age"+s1.getAge());
    }
}

结果为：

封装的意义

1. 
   提高程序的安全性
   
2. 
   隐藏代码的实现细节
   
3. 
   统一接口
   
4. 
   系统可维护性增加了
   

继承

继承的本质是对某一批类的抽象，从而实现对世界更好的建模。

extends

extends的意思是“扩展”。子类是父类的扩展。

Java类中只有单继承，没有多继承。

在Java中，所有的类都默认直接或者间接继承object类

• 继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等。
• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
• 子类和父类之间，从意义上讲应该具有“ is a”的关系。

1. object类
2. super
3. 方法重写：重点—->多态

可以这样表达：

public class Student extends Person{}

例：继承父类的方法

学生类（子类）：

//学生 is 人：子类
//子类继承了父类，就会拥有父类的全部方法！
public class Student1 extends Person {

}

人类（父类）：

//Person 人：父类
public class Person {
    public int money=10_0000_0000;
    public void say(){
        System.out.println("说了一句话");
    }
}

最后交由Application类实现：

import OOP.Demo.demo01.Student1;

public class Application {
    public static void main(String[] args) {
        Student1 student=new Student1();
        student.say();
        System.out.println(student.money);
    }
}

结果为：

关于public和private、default、protected：

• public属于公共的，可以被子类继承，权限最高。
• private为私有的，无法被子类继承。
• default为默认的，可以忽略不写。
• protected为受保护的。

快捷键 Ctrl+H可以打开继承树。

super

例：

结果：

验证执行顺序：

子类默认调用父类的无参，若需要调用有参，则需要写在super( );方法的括号中以说明。

小结

1. 
   super注意点：
   

• 
  super调用父类的构造方法，必须在构造方法的第一个。
  
• 
  super必须只能出现在子类的方法或者构造方法中！
  
• 
  super和this不能同时调用构造方法！
  

2. 
   this注意点：
   

与super相比，this代表的对象不同：

• 
  this：本身调用者这个对象。
  
• 
  super：代表父类对象的应用。
  

前提：

• 
  this：没有继承也可以使用
  
• 
  super：只能在继承条件下才能使用
  

构造方法：

• 
  this（）；本类的构造。
  
• 
  super（）；父类的构造，
  

重写

重写都是方法的重写，与属性无关

重写后

可以理解为：静态属于类，非静态属于对象。

静态方法是类的方法，非静态是对象的方法。

B b=new A();//子类重写了父类的方法
			//静态方法和非静态方法区别很大

重写的关键字只能是

public


小结：

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

1. 
   方法名必须相同
   
2. 
   参数列表必须相同
   
3. 
   修饰符：范围可以扩大，但不可缩小 public > protected > default > private
   
4. 
   抛出的异常：范围可以被缩小，但不能扩大 ClassNotFoundException –>Exception（大）
   

子类的方法必须和父类的一致：方法体不同。

为什么需要重写？

• 
  父类的功能，子类不一定需要，或者不一定满足。
  

Alt + Insert ：@override 即为重写；

多态

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

一个对象的实际类型是确定的，但可以指向对象的引用类型有很多。（父类及有关系的类）

多态存在条件：

• 
  有继承关系
  
• 
  子类重写父类方法
  
• 
  父类引用指向子类对象
  

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

关键词：instanceof （类型转换） 引用类型，判断一个对象是什么类型

例

可见，父类调用了子类独有的方法，所以发生了报错。

注意事项

1. 
   父类和子类，有联系。
   

常见报错：ClassCastException 类型转换异常

2. 
   存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son( ) ;
   

无法重写

1. 
   static 方法：属于类，不属于实例；
   
2. 
   final 常量；
   
3. 
   private私有方法；
   

instanceof

判断两个类是否存在父子关系

		//Object > String
        //Object > Person >Teacher
        //Object > Person >Student1
        Object object=new Student1();
        System.out.println(object instanceof Student1);//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 Student1();
        System.out.println(person instanceof Student1);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//false
        System.out.println(person instanceof String);//编译错误
        System.out.println("--------------------------");
        Student1 student1=new Student1();
        System.out.println(student1 instanceof Student1);//true
        System.out.println(student1 instanceof Person);//true
        System.out.println(student1 instanceof Object);//true
        System.out.println(student1 instanceof Teacher);//编译错误
        System.out.println(student1 instanceof String);//编译错误

公式

System.out.println(X instanceof Y);

是否可以编译通过，取决于X与Y是否存在父子关系

例

public class Student1 extends Person {
    public void go(){
        System.out.println("go");
    }

public class Application {
    public static void main(String[] args) {
        //类型之间的转化： 父<-->子
        //高                  低
        Person obj=new Student1();
        //将这个对象转化为Student1类型，我们可以使用Student类型的方法了
        ((Student1)obj).go();
    }
}

子类转换为父类，可能丢失自己本来的一些方法

小结：

1. 
   父类引用指向子类的对象；
   
2. 
   把子类转换为父类，向上转型；
   
3. 
   把父类转换为子类，向下转型； 强制转换
   
4. 
   方便方法的调用，减少重复的代码；