构造器

构造器

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

    public Person() {
    }

    public Person(int age) {
        this.age = age;
    }

    public Person(int age, String name, int sex) {
        this.age = age;
        this.name = name;
        this.sex = sex;
    }
}

特点：

1. 和类名名字相同
2. 没有返回值

作用：

1. new 本质是在调用构造方法
2. 初始化对象的值

注意点：

1. 定义了有参构造之后，如果想使用无参构造，必须定义一个无参构造
2. this 表示当前所在的类

---

封装：

属性私有，get/set

作用：通常，应禁止直接访问一个对象中数据的实际表示，而应通过 *** 作接口来访问，这称为信息隐藏。

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

    public Person() {
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public int getSex() {
        return sex;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }
}

---

继承

在Java中， 所有的类，都默认直接或者间接继承0bject类

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

extends的意思是“扩展”。子类是父类的扩展。

JAVA中类只有单继承，没有多继承! 一个儿子只能有一个爸爸,但是一个爸爸可以有多个儿子。

继承是类和类之间的一种关系。除此之外类和类之间的关系还有依赖、组合、聚合等。
继承关系的俩个类，一个为子类(派生类),一一个为父类(基类)。 子类继承父类使用关键字extends来表示。

示例：定义一个Teacher子类继承上文Person父类

public class Teacher extends Person{
}

super的用法示例：

public class Person {
    protected int age;
    protected String name;
    protected int sex;
    public void print(){
        System.out.println("Person");
    }
}

public class Student extends Person{
    private String name;
    public void print(){
        System.out.println("Student");
    }
    public void test(){
        print();
        this.print();
        super.print();
    }
}

public class Day1 {
    public static void main(String[] args) {
        Student student = new Student();
        student.test();
    }
}

super的用法效果：

super注意点:

1. super调用父类的构造方法，必须在构造方法的第一个
2. super必须只能出现在子类的方法或者构造方法中!
3. super和this不能同时调用构造方法!
4. this 和 super的区别：
   i. 代表的对象不同:
   this:调用本身这个对象
   super:
   代表父类对象的引用
   ii. 前提
   this:没有继承也可以使用
   super:只能在继承条件才可以使用
   iii. 构造方法
   this() ;本类的构造
   super():父类的构造
5. 调用本身类的无参构造，会默认也调用父类的无参构造

---

重写:

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

重写只跟非静态方法有关

重写的修饰符只能用public

示例1：

静态方法：

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

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

public class Day1 {
    public static void main(String[] args) {
        //静态类方法：方法的调用只和左边定义的类型有关
        A a = new A();
        a.test();
        //父类的引用指向了子类
        B b = new A();
        b.test();
    }
}

效果1：

示例2

非静态方法：

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

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

public class Day1 {
    public static void main(String[] args) {
        A a = new A();
        a.test();
        B b = new A();//子类重写了父类的方法
        b.test();
    }
}

效果2：

重写的用法和作用

1. 方法名必须相同

2. 参数列表列表必须相同

3. 修饰符:范围可以扩大但不能缩小:
   public > Protected > Default > private

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

5. 子类的方法和父类必要一致，但方法体不同!

6. 为什么需要重写:

   父类的功能，子类不一定需要，或者不一定满足!

多态: 注意事项:

1.多态是方法的多态，属性没有多态
2.父类和子类，有联系才能转换，否则会报错：类型转换异常! ClassCastException!
I
3.存在条件: 继承关系，方法需要重写，父类引用指向子类对象!

以下几种情况是不能进行方法重载的

1. static 方法，属于类，它不属于实例
2. final 常量;
3. private方法;

多态示例：

public class Person {
    protected int age;
    protected String name;
    protected int sex;
    public void print(){
        System.out.println("Person");
    }
}

public class Student extends Person{
    protected int age;

    @Override
    public void print() {
        System.out.println("Student");
    }
    public void eat(){
        System.out.println("吃东西");
    }
}

public class Day1 {
    public static void main(String[] args) {
        //Student 能调用的方法是自己的或者继承父类的
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法，比如这里就不能调用子类的eat()方法
        Person s2 = new Student(); //多态

    }
}

instanceof关键字的使用 作用：

• 用于判断左边的对象是否是右边的类的对象实例

• 类的实例包含本身的对象，以及所有直接或间接的子类的对象

注意点：

1. 左边的对象实例不能是基础数据类型
2. 左边的对象实例和右边的类不在同一个继承树上
3. NULL跟任何类型比较时都是false

示例1:

//继承树
/*
1. Object > String
2. Object > Person > Teacher
3. Object > Person > Student
*/

public class Person {}

public class Teacher extends Person{}

public class Student extends Person{}

Object s1 = new Student();
System.out.println(s1 instanceof Student);//true
System.out.println(s1 instanceof Object);//true
System.out.println(s1 instanceof Person);//true
System.out.println(s1 instanceof Teacher);
//false：Teacher在s1的继承树下可以编译，但是不在Object->Student这颗继承树上
System.out.println(s1 instanceof String);
//false：String在s1的继承树下可以编译，但是不在Object->Student这颗继承树上

Person s1 = new Student();
System.out.println(s1 instanceof Student);//true
System.out.println(s1 instanceof Object);//true
System.out.println(s1 instanceof Person);//true
System.out.println(s1 instanceof Teacher);//false
//System.out.println(s1 instanceof String);
//无法编译,因为左边的对象s1跟右边的String类不在一棵继承树上

Student s1 = new Student();
System.out.println(s1 instanceof Student);//true
System.out.println(s1 instanceof Object);//true
System.out.println(s1 instanceof Person);//true
//System.out.println(s1 instanceof Teacher);
//无法编译,因为左边的对象s1跟右边的Teacher类不在一棵继承树上
//System.out.println(s1 instanceof String);
//无法编译,因为左边的对象s1跟右边的String类不在一棵继承树上