Java随堂小记07

封装

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

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

快捷键alt+insert

package www.Dongyi.oop;


public class Demo2 {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("dy小仙女");

        System.out.println(s1.getName());
        s1.setAge(999);//不合法的
        System.out.println(s1.getAge());

    }
}

package www.Dongyi.oop;

public class Student {
    private String name;
    private int id;
    private char gender;
    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 getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 120 || age < 0) {
            this.age = 3;
        } else {
            this.age = age;
        }
    }
}

继承

格式： 子类 extends 父类

Java中类只有单继承，没有多继承，即一个子类只有一个直接父类

继承是类和类之间的一种关系。

package www.Dongyi.oop;

public class Father {
    public void say(){
        System.out.println("说了一句话");
    }

    private int money = 10_0000_0000;

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

package www.Dongyi.oop;

public class Son extends Father {
    //子类继承了父类，就会拥有父类的全部方法！


}

package www.Dongyi.oop;

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

        Son son = new Son();
        son.say();
        son.setMoney(9_0000_0000);
        System.out.println(son.getMoney());
    }
}

Object

快捷键 Ctrl+h

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

super

package www.Dongyi.oop.Demo4;

import www.Dongyi.oop.Demo4.Person;

public class Student extends Person {
    public Student() {
        //隐藏代码：调用了父类的无参构造super();调用父类构造器必须要在子类和构造器的第一行
        System.out.println("Student无参执行了");
    }

    private String name = "Student";

    public void test1(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }

    public void test2(){
        print();
        this.print();
        super.print();
    }

    public void print(){
        System.out.println("Student：dy");
    }
}

package www.Dongyi.oop.Demo4;

public class Person {
    public Person() {
        System.out.println("Person无参执行了");
    }

    protected String name = "Person";

    public void print(){
        System.out.println("Person：dy");
    }
    //私有的东西无法继承
}

package www.Dongyi.oop.Demo4;

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

        Student student = new Student();
        student.test1("dy小仙女");
        student.test2();
    }
}

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

this和super
代表的对象不同：
this：本身调用者这个对象
super：代表父类对象的引用
前提
this：没有继承也可以使用
super：只能在继承条件下才可以使用
构造方法
this();本类的构造
super();父类的构造

方法重写

重写只能是非静态、public
快捷键：alt+insert

package www.Dongyi.oop.Demo5;

public class A extends B{
    //alt+insert

    //Override 重写
    @Override//注解：有功能的注释！
    public void test() {
        System.out.println("A=>test");
    }
}

package www.Dongyi.oop.Demo5;

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

package www.Dongyi.oop.Demo5;

public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.test();

        //父类的引用指向了子类
        B b = new A();
        b.test();
    }
}

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

重写：需要有继承关系，子类重写父类的方法！
1.方法名必须相同
2.参数列表必须相同，否则就像重载
3.修饰符：范围可以扩大： public > protected > default > private
4.抛出的异常：范围，可以被缩小，但不能扩大

重写：子类和父类方法一致，方法体不同

多态

package www.Dongyi.oop.Demo6;

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

package www.Dongyi.oop.Demo6;

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

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

package www.Dongyi.oop.Demo6;

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

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

        s2.run();//子类重写了父类的方法，执行子类的方法
        s1.run();

        //对象能运行哪些方法，主要看左边的类型，和右边关系不大
        //s2.eat();会报错
        s1.eat();
        ((Student) s2).eat();//强制类型转换
    }
}

多态注意事项：
1.多态是方法的多态，属性没有多态！
2.父类和子类要有联系，否则类型转换异常！ClassCastException!
3.存在条件：继承关系；方法重写；父类引用指向子类对象！ Father f1 = new Son();

以下不能重写
1.static 方法属于类，不属于实例，不能重写
2.final 常量
3.private方法
不能重写就没有多态！

父类的方法子类可以调用，子类和父类共同的方法就调用子类，因为子类重写了父类的方法