JavaSE Day08

面向对象（2）

 

1. 封装

高内聚，低耦合。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

属性私有！！ private 关键字 get/set方法（alt+insert 自动生成）

package com.oop.demo03;
 ​
 //类   private:私有
 public class Student {
 ​
     //属性私有
     private String name;//名字
     private int id;//学号
     private char sex;//性别
     private int age;
 ​
     public String getName() {
         return name;
     }
 ​
     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 < -1)
             age = 3;
         else
             this.age = age;
     }
 }

package com.oop;
 ​
 import com.oop.demo03.Student;
 ​
 public class Application {
     public static void main(String[] args) {
         Student student1 = new Student();
         student1.getName();
         student1.setName("azy");
 ​
         student1.setAge(999);//不合法
         System.out.println(student1.getAge());
     }
 }

封装的好处：

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

2. 隐藏代码的实现细节

3. 统一接口，全是get、set

4. 系统可维护性增加了

 

2. 继承

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

继承是类和类之间的关系，子类继承父类，用关键字extends

Java中只有单继承，一个儿子只有一个爸爸，一个爸爸有多个儿子

package com.oop.demo04;
 ​
 //Person 人     ：父类
 public class Person {
     public int money = 10_0000_0000;
     private int money1 = 10000;
     int money2 = 100;//default
     protected int money3 = 100000;//保护级最高
 ​
     public void say() {
         System.out.println("aaaa");
     }
 ​
     public int getMoney1() {
         return money1;
     }
 ​
     public void setMoney1(int money1) {
         this.money1 = money1;
     }
 }

 package com.oop.demo04;
 ​
 //学生 is 人     ：派生类，子类
 public class Student extends Person {
 }
 package com.oop.demo04;
 ​
 public class Teacher extends Person {
 }
 package com.oop;
 ​
 import com.oop.demo04.Student;
 ​
 public class Application {
     public static void main(String[] args) {
         //Student 继承了Person类！
         Student s1 = new Student();
         s1.say();
         System.out.println(s1.money);
 ​
     }
 }

Ctrl+H 打开继承关系

在Java中所有的类，都默认继承object！！

 

3. private，protect，this，super关键字

super注意点：

1. super调用父类的构造方法，必须在构造器方法的第一个

2. super必须只能出现在子类的方法或者构造方法中！

3. super 和 this 不能同时调用构造方法！

vs this：

1. 代表的对象不同：　　

　　　　this：本身调用者这个对象

　　　　super：代表父类对象的应用

2. 前提

　　　　this：没有继承也可以使用

　　　　super：只能在继承后使用

3. 构造方法

　　　　this（）：本类的构造

　　　　super（）：父类的构造

 package com.oop.demo04;
 ​
 //Person 人     ：父类
 public class Person {
     protected String name = "yc";
 ​
     public void print() {
         System.out.println("Person");
     }
 }

package com.oop.demo04;
 ​
 //学生 is 人     ：派生类，子类
 public class Student extends Person {
     public Student() {
         //隐藏代码，调用了父类的无参构造
         super();//必须放在子类构造器的第一行
     }
 ​
     private String name = "azy";
 ​
     public void setName(String name) {
         System.out.println(name);
         System.out.println(this.name);
         System.out.println(super.name);
     }
 ​
     public void print() {
         System.out.println("Student");
     }
 ​
     public void test() {
         print();
         this.print();
         super.print();
     }
 }

package com.oop;

import com.oop.demo04.Student;

public class Application {
    public static void main(String[] args) {

        Student student = new Student();
        student.setName("xiaolaji");

        System.out.println("--------------------");
        student.test();

    }
}

输出：

xiaolaji

azy

yc

Student

Student

Person

 

4. 方法重写

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

package com.oop.demo04;

public  class B {
    public static void test(){
        System.out.println("B->test");
    }
}

package com.oop.demo04;

public class A extends B{
    public  static void test() {
        System.out.println("A->test");
    }
}

package com.oop;

import com.oop.demo04.A;

public class Application {
    public static void main(String[] args) {

        A a = new A();
        a.test();
        B b = new A();
        a.test();

    }
}

A->test

B->test

package com.oop.demo04;

public  class B {
    public void test(){
        System.out.println("B->test");
    }
}

package com.oop.demo04;

public class A extends B{
    @Override //重写
    public void test() {
        System.out.println("A->test");
    }
}

去了static

A->test

A->test

（ 因为静态方法是类的方法，而非静态是对象的方法；有static时，b调用了B类的方法，因为b是用b类定义的；没有static时，b调用的是对象的方法，而b是用A类new的；即b是A new出来的对象，因此调用了A的方法 ）

得出结论，静态方法和非静态方法区别很大！

静态方法：方法的调用只和左边，定义的数据类型有关

非静态：重写

 

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

1. 方法名必须相同

2. 参数列表必须相同

3. 修饰符：范围可以扩大 public> protected> default> private

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

重写，子类的方法和父类必须要一致；方法体不同！

为什么需要重写？                父类的功能子类不一定需要，或者不一定满足               alt+insert ---> override

 

5. 多态

动态编译：类型（可扩展性）

package com.oop.demo05;

public class Person {
    public void run(){
        System.out.println("run");
    }

}

package com.oop.demo05;

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}

package com.oop;

import com.oop.demo05.Person;
import com.oop.demo05.Student;

public class Application {
    public static void main(String[] args) {

        //一个对象的实际类型是确定的
        //可以只想的引用类型就不确定了

        //Student 能调用的方法都是自己的或者是继承父类的
        Student s1 = new Student();
        //Person 父类型，可以执行子类，但是不能调用子类独有的
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行哪些方法，主要看对象左边的类型（Student、Person、Object），和右边关系不大！

        s2.run();//son，子类重写了父亲的方法
        s1.run();//son
        s1.eat();
        //s2.eat();不可调用
        ((Student) s2).eat();
    }
}

多态注意事项：

1. 多态是方法的多态，属性没有多态

2. 父类和子类，有联系 类型转换异常    ClassCastException

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

不能被重写：

1. static 方法不能重写，属于类，它不属于实例

2. final 常量

3. private 方法

 

6. instanceof 关键字

System.out.println(X instanceof Y); 能不能编译通过，主要是看X和Y 有没有父子关系

package com.oop;

import com.oop.demo05.Person;
import com.oop.demo05.Student;
import com.oop.demo05.Teacher;

public class Application {
    public static void main(String[] args) {

        //Object > String
        //Object > Person > Student
        //Object > Person > Teacher
        Object object = new Student();

        System.out.println(object instanceof Student);//ture
        System.out.println(object instanceof Person);//ture
        System.out.println(object instanceof Object);//ture
        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);//ture
        System.out.println(person instanceof Person);//ture
        System.out.println(person instanceof Object);//ture
        System.out.println(person instanceof Teacher);//false
        // System.out.println(person instanceof String);//编译报错！

        System.out.println("---------------");
        Student student = new Student();
        System.out.println(student instanceof Student);//ture
        System.out.println(student instanceof Person);//ture
        System.out.println(student instanceof Object);//ture
        //  System.out.println(student instanceof Teacher);//编译报错！
    }
}

 

7. 类型转换

低（子）--->高（父） 向上转型。可以直接转，丢失子类中原本可以直接调用的特有方法

高（父）--->低（子） 向下转型。需要强转，丢失父类被子类所重写的方法

package com.oop;

import com.oop.demo05.Person;
import com.oop.demo05.Student;
import com.oop.demo05.Teacher;

public class Application {
    public static void main(String[] args) {
        //类型之间的转换： 父  子


        Person student = new Student();
        //低（子）--->高（父） 向上转型。可以直接转，丢失子类中原本可以直接调用的特有方法
        //高（父）--->低（子） 向下转型。需要强转，丢失父类被子类所重写的方法
        Person person = student;

        //student.go();//不能通过
        //将student这个对象转化为Student类型，我i们就可以使用Student类型的方法了！

        ((Student) student).go();
    }
}