Java学习笔记9（面向对象二：this、继承、抽象类）

就近原则：

类中的方法中的变量和成员变量重名时，调用类的方法时候，生效的是方法中的变量，如果方法中没有定义变量，才会去成员变量中寻找

于是，提出了this关键字，为了区分重名问题

public class Person {
    // 人的姓名年龄，成员变量
    private String name;
    private int age;

    public void setAge(int a) {
        if (a < 0 || a > 100) {
            age = 20;
        } else {
            age = a;
        }
    }
    public void setName(String n){
        name = n;
    }
    
    //定义方法，获取age
    public int getAge(){
        return age;
    }
    public String getName(){
        return name;
    }
    
    // 说话功能
    public void speak() {
        String name = "李四";
        int age = 16;
        System.out.println(this.age + "岁的" + this.name + "在说话");
    }

}

public class PersonTest {

    public static void main(String[] args) {
        Person p = new Person();
        p.setName("张三");
        p.setAge(80);
        System.out.println(p.getAge());
        System.out.println(p.getName());
        p.speak();
    }
}

这里如果不写this，输出的就是李四，如果写了则输入张三

 注意this是调用者本身的对象

this内存分析：

 1.main进栈运行，堆中开空间存入Person对象，成员变量跟随并赋默认值

2.p调用speak方法时，speak进栈执行，调用者是p对象，this就是p对象本身，因此p将对象地址传递给this，于是this也指向这一片内存空间

于是我们发现，刚才的Person类这样写会更规范：

public class Person {
    private String name;
    private int age;

    public void setAge(int a) {
        if (a < 0 || a > 100) {
            this.age = 20;
        } else {
            this.age = a;
        }
    }

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

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public void speak() {
        String name = "李四";
        int age = 16;
        System.out.println(this.age + "岁的" + this.name + "在说话");
    }

}

继承：

类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类

子类会自动拥有父类所有可继承的属性和方法

 举例：

public class Employee {
    String name;
    public void work(){
        System.out.println("员工"+name+"在工作");
    }
}

public class Develop extends Employee{
    public void print(){
        System.out.println(name);
    }
}

public class Test {

    public static void main(String[] args) {
        Develop d = new Develop();
        d.name = "张三";
        d.print();
        d.work();
    }

}

 继承的特点和优点在这个例子中都体现出了

1.提高代码的复用性，提升开发效率

2.继承的出现让类与类之间产生了关系，提供了多态的前提

注意事项：

java只支持单继承，不支持多继承，因为有安全隐患，例如两个父类有重名方法时

可以使用连续继承（多重继承）实现多继承，这种方式合法

成员变量的变化：

子类定义的变量如果和父类重名，调用子类的时候，以子类的变量为准，如果子类不存在这个变量，则去父类中寻找，但是有一个super关键词可以指定在父类中寻找

public class Fu {
    int i = 1;
}

public class Zi extends Fu {
    int i = 2;
    public void show(){
        System.out.println(super.i);
    }
}

public class Test {

    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }

}

这时候的输出结果为1，关于super的知识在后面详写

子类重写父类方法：

子类中，出现了和父类一样的方法的时候，称为子类重写父类的方法

用super.调用父类的功能，再写入新的功能

注意：子类如果要覆盖父类方法，必须要保证权限大于或等于父类权限（public>protected>default>private）

抽象类：

只有声明，没有定义

抽象方法必须存在于抽象类中

抽象类，不能实例化对象（不能使用new）因为抽象类没有主体，无法运行

抽象类的使用：必须定义类继承它，将抽象方法重写，创建它的子类的对象，并且强制让子类重写方法

public abstract class Person {
    public abstract void work();
}

public class Teacher extends Person {
    public void work() {
        System.out.println("老师在工作");
    }
}

public class Engineer extends Person {

    public void work() {
        System.out.println("工程师在工作");
    }

}

public class Test {

    public static void main(String[] args) {
        Teacher t = new Teacher();
        Engineer e = new Engineer();
        t.work();
        e.work();
    }

}

 输出：

老师在工作
工程师在工作

抽象类主要是为了学习它的设计思想：

抽象类的作用：继承的体系

抽象类强制子类重写抽象方法，保证体系功能的完整性

抽象类的一些注意事项：

1.有抽象方法的一定是抽象类，抽象类不止有抽象方法

2.抽象关键字abstract不可以共存的：private,final,static

3.抽象类必须是父类