零基础入门学习Java课堂笔记 ——day06

面向对象（中）

1.封装

“高内聚，低耦合”

高内聚：类内部的细节自己完成，不允许外部干涉

低耦合：仅暴露少量方法给外部使用

属性私有

---

在Java中可以通过private关键字给方法类定义私有的属性，private关键字只允许本类使用私有的属性

如果想获取和更改属性值可以通过get/set获取或设置

编写Student.java如下

编写App.java如下：

总结：

• 提高系统安全性、保护数据。
• 隐藏代码的实现细节
• 统一接口
• 系统可维护性

2.继承

在Java中，我们可以使用extend使得子类继承父类

package pro;

public class Person {
    String name = "";
    int age = 0;
    public Person(String name,int age){
        System.out.println("You are creat a person");
        this.age = age;
        this.name = name;
    }

    public void say(){
        System.out.println("You are good boy!!!");
    }

    private void say(String sentence){
        System.out.println(sentence);
    }
}

package pro;
import pro.Person;

public class Student extends Person{

    public Student(String name, int age) {
        super(name, age);//继承父类结构器
    }
}

通过上面的代码，我们可以在子类对象调用父类public方法

package pro;
import pro.Student;

public class App {
    public static void main(String[] args){
        Student stu = new Student("Hu Xiao",18);
        stu.say();
    }
}

如果你不想让子类调用可以利用private关键词修饰方法

如果想只让子类调用可以使用protect关键词来修饰

（此处忽略1000行代码 略略~）

Java是单继承不是多继承

拓展：Java中的所有类都默认继承Object类

super

---

在Java语言中，如果子类想访问父类的属性可以通过继承的super关键词，如下：

package pro;
import pro.Student;

public class App {
    public static void main(String[] args){
        Student stu = new Student();

        stu.changeName("HuMouRen");
    }
}

输出结果为

HuMouRen
Student
Person

如果子类定义了构造器，就必须在构造器中添加super()方法在最前面，并且把父类所需要的参数通过这个方法传递给父类，父类构造器没有需要传递的参数可以省略super方法，Java将在编译时帮你定义

package pro;

public class Person {

    protected String name = "Person";
    public Person(String name){
        this.name = name;
        System.out.println("It's super.");
    }
}

package pro;
import pro.Person;

public class Student extends Person{

    private String name = "Student";

    public Student(String name){
        super(name);//必须在本类构造器代码前面

        System.out.println("Hello world!!!");
    }

}

如果我们一定要子类的构造器无参的话，可以通过重载的方法，对子类或者父类添加一个无参构造器即可

package pro;

public class Person {

    protected String name = "Person";
    public Person(String name){
        this.name = name;
        System.out.println("It's super.");
    }

    public Person(){

    }
}

package pro;
import pro.Person;

public class Student extends Person{

    private String name = "Student";

    public Student(){

    }
}

Super总结注意点：

• super指的是父类对象

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

• super只能出现在子类的方法或者构造器

• super和this不能同时调用构造方法

  ​ VS

This注意点:

• this指的是本类的对象
• this是本类的构造

重写

---

在Java中如果子类和父类有同样名称同样参数的方法，Java默认会调用父类的方法，将此操作称之为方法的重写

package pro;

public class Person {
    public void test(){
        System.out.println("It's Person test.");
    }

}

package pro;
import pro.Person;

public class Student extends Person{
    public void test(){
        System.out.println("It's Student test.");
    }

}

package pro;
import pro.Student;

public class App {
    public static void main(String[] args){
        Student stu = new Student();
        stu.test();//It's Student test.
    }
}

注意点：如果方法有static修饰，那么就不叫重写，只有不被static修饰的方法才能重写 如:

Person stu2 = new Student();
stu.test() //如果test方法由static修饰此处输出It's Person test.

总结：

• 前提：需要有继承关系且子类重写父类的方法

  • 方法名必须相同
  • 参数列表必须相同
  • 继承后的方法修饰符可以扩大但不能缩小比如说原本是
    • protect ===>public
  • 抛出异常的范围，可以被缩小但不能扩大

• 从写子类的方法必须和父类要一致，方法体不同

3.多态

我们可以创建一个父类的对象指向子类，但父类的对象只能调用和子类共有的部分

package pro;

public class Person {
    public void test(){
        System.out.println("It's Person test.");
    }

}

package pro;
import pro.Person;

public class Student extends Person{
    public void test(){
        System.out.println("It's Student test.");
    }

    public void eat(){
        System.out.println("eat!!!");
    }

}

package pro;
import pro.Student;

public class App {
    public static void main(String[] args){
        Student stu1 = new Student(); //Student==>Student
        Person stu2 = new Student();//Person==>Student
        Object stu3 = new Student();//Object==>Student

        stu1.test(); //true
        stu1.eat(); //true
        stu2.test(); //true

        stu3.test(); //false
        stu2.eat(); //false

    }
}

如果一定要对stu3和stu2执行操作的话，我们可以通过强制类型转换将其转换为Student

package pro;
import pro.Student;

public class App {
    public static void main(String[] args){
        Student stu1 = new Student();
        Person stu2 = new Student();
        Object stu3 = new Student();

        stu1.test(); //true
        stu1.eat(); //true
        stu2.test(); //true

        ((Student)stu3).test(); //true
        ((Student)stu2).eat(); //true
    }
}

总结：

• 多态是方法的多态属性没有多态
• 必须存在父类和子类的联系 否则：ClassCastException！
• 创建父类引用指向子类 且方法需要重写
• Father F1 = new Son();
• 没有重写，没有多态！！！