对象学习

this关键字

当在一个作用域访问变量时,先在当前作用域找,找的到的话,就不再继续查找,找不到的话去外层作用域去找,如果找到就不再查找,找不到的话继续上一层,以此类推,整个类中都没有,那么就会报错.

局部变量和成员变量的二义性,

解决方法:1.改变变量名2.this关键字

内存图

this是一个对象,实例.name

构造器和setter方法

构造器,在创建对象的时候设置数据,可以设置一次,再次改变值的时候就创建了一个新对象

set创建对象后再设置初始数据,可以设置多次

继承

父类:存放共同的字段和方法

子类:继承父类的类,存放自己特有的方法和字段

public class Person{
    String name;
    int age;
    
    public void rest(){
        System.out.println(this.name + "休息");
    }
}

public class Teacher extends Person{
    int level;
    
    public void teacher(String aClassName){
        System.out.println("授课:" + aClassName);
    }
    
    public void showInfo(){
        System.out.println(this.name);
        System.out.println(this.age);
        System.out.println(this.level);
    }
}

public class Deom {
    public static void main(String[] args) {
        Teacher t = new Teacher();
        //t有三个字段
        //t特有的字段
        t.level = 1;
        //t继承自person的字段
        t.age = 20;
        t.name = "张三";
        //t继承自person的方法
        t.rest();
        //t特有的方法
        t.teacher("java");
        t.showInfo();
    }
}

总结:1.继承让子类拥有父类的字段和方法

2.在java中一个类只能有一个直接父类,java类是单继承(单根性),

3.但是可以支持多重继承,也就是父类可以再有父类(传递性).

4.如果一个类没有显式的继承任何类,它一定继承自object类,object是java的根类

但是一个父类可以有多个子类

public class Person{
    private String name;
    private int age;
    
    public void setName(String name){
    	this.name = name;    
    }
    
    public String getName(){
        return name;
    }
    
    public void setAge(int age){
        this.age = age;
    }
    
    public int getAge(){
        return age;
    }
    
    public Person(){}
    
    public void rest(){
        System.out.println(this.name + "休息");
    }
}

public class Teacher extends Person{
    //有三个字段,只不过不能直接访问name和age,需要通过设置器来设置
    int level;
    
    public void teacher(String aClassName){
        System.out.println("授课:" + aClassName);
    }
    
    public void showInfo(){
        System.out.println(this.getName());
        System.out.println(this.getAge());
        System.out.println(this.level);
    }
}

修饰符

1.如果父类中的成员使用public和protected修饰,子类都可以继承

2.父类和子类在同包,使用缺省的,子类可以继承

3.父类中的成员使用private修饰,子类可以继承到,但是不能够直接访问,能够直接访问的一定是非私有的

4.父类的构造方法,子类不能够继承,因为构造方法必须和类名相同

关键字	本类	同包子类	同类其他包	不同包子类	不同包其它类
private	√	×	×	×	×
默认	√	√	√	×	×
protected	√	√	√	√	×
public	√	√	√	√	√

private: 私有的,本类可见

默认: 同包可见

protected: 受保护的,同包可见,子类可见

public: 公开的,任意地方都可见

访问权限: private < 默认 < protected < public

方法覆盖

重写/覆盖的概念(overread/overWrite)

当子类从父类继承过来的方法,不能满足自身需要时,子类可以选择重写/覆盖父类中的同名方法

public class Bird{
    public void fly(){
        System.out.println("飞呀飞...");
    }
}

public class Ostrich extends Bird{
    public void fly(){
        System.out.println("跑...");
    }
}

public static void main(String[] args){
    Ostrich o = new Ostrich();
    o.fly();
}

1.方法签名必须相同

2.子类方法的返回值和父类方法的返回值相同或者是父类的子类

public Dog product(){
        Dog son = new Dog();
        return son;
    }
//子类的返回值是dog属于pet的子类,此时就是可以构成重写
public Dog product(){
        Dog son = new Dog();
        return son;
    }

3.子类的访问修饰符权限大于等于父类的

4.如果父类方法是private,子类方法不能重写,没有继承不能重写

5.子类方法声明抛出的异常小于或者等于父类声明抛出的异常

当需要调用父类成员时,一定使用super

public void showInfo(){
        System.out.println(this.health);
        System.out.println(this.love);
        System.out.println(this.name);
    }

//当发现还需要使用父类中的方法的时候,就要用到super关键字
public void showInfo(){
//        System.out.println(this.getHealth());
//        System.out.println(this.getLove());
//        System.out.println(this.getName());
        super.showInfo();
        System.out.println(this.strain);
    }

抽象方法

1.抽象方法必须位于抽象类中

2.一个类继承了一个抽象父类,必须实现抽象父类中的所有抽象方法,实现(implement)是一种特殊的重写

3.抽象方法没有方法体

抽象方法的特点:1.使用abstr修饰,没有方法体,留给子类去覆盖

2.抽象方法定义在抽象类或者接口中

抽象类的特点:

1.抽象类太过于抽象,不能够实例化/创建对象,抽象类可以组织实例化

2.抽象类要有子类才有意义,子类必须覆盖父类的抽象方法,否则会报错

3.抽象类中可以有普通方法

public abstract class Graph {
    
    public abstract double getArea();
}

public class Circle extends Graph{
    private double r;

    public void setR(double r) {
        this.r = r;
    }

    public double getR() {
        return r;
    }

    @Override
    public double getArea() {
        return 3.14 * r * r;
    }
}

object类

API文档

先了解tostring和equals

在java中输出一个引用数据类型的变量时,默认调用tostring方法

Object toString默认输出的是内存地址,可以通过重写的方法去得到自己想要的结果

判断两个对象是否相等

如果两个对象的地址相等,那么我们认为这两个对象相等

== 引用数据类型,比较的是内存地址

Object equals默认比较的是地址