JAVA基础（四）面向对象

1.什么是面向对象(属性+方法)

2.创建和初始化对象

3.构造器

4.创建对象内存分析

小结

5.封装（面向对象3大特性之一）

6.继承（面向对象3大特性之一）

在java中所有类都默认直接或间接继承Object类
指针，this指向当前类，super指向父类。

子类的构造器会先调用父类的构造器；
调用父类的构造器，必须要在子类构造器的第一行。

super注意点：
①super调用父类的构造方法，必须在构造方法的第一个；
②super必须只能出现在子类的方法或者构造方法中；
③super和this不能同时调用构造方法
VS this：
①代表的对象不同：this，本身调用这个对象；super，代表父类对象的应用。
②前提：this，没有继承也可以使用；super，只能在继承条件才可以使用。
③构造方法：this()，本类的构造；super()，父类的构造。

（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 Application {
    public static void main(String[] args) {

        //方法的调用只和左边，定义的数据类型有关
        A a =new A();
        a.test();

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

    }
}

②

//重写都是方法的重写，和属性无关
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 Application {
    public static void main(String[] args) {

        //静态的方法和非静态的方法区别很大
            //静态方法：方法的调用只和左边，定义的数据类型有关

        //非静态：重写
        A a =new A();
        a.test();

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

    }
}

重写：需要有继承关系，子类重写父类的方法！
①方法名必须相同；
②参数列表必须相同；
③修饰符：范围可以扩大但不能缩小，public>protected>default>private
④抛出的异常：范围可以被缩小，但不能扩大。classNotFoundException --> Exception(大)
重写，子类的方法和父类必须要一致，方法体不同。
** 为什么需要重写：父类的功能，子类不一定需要，或者不一定满足**

6.多态（面向对象3大特性之一）

（1）多态的小例子

public class Person {
    public void run(){
        System.out.println("人run");
    }
}
public class Student extends Person{
    public void run(){
        System.out.println("学生run"); //重写了父类的run()方法
    }

    public void eat(){
        System.out.println("学生eat");
    }
}
public class Application {
    public static void main(String[] args) {
        /*
        一个对象的实际类型是确定的
        new Student();
        new Person();
         */

        /*
        可以指向的引用类型就不确定了： 父类的引用可以指向子类，
        因为：子类继承了父类的属性和方法 （简单来说就是 父类的对象可以借用子类来生成，但有局限性）
         */

        //Student 能调用的方法都是自己的或者继承父类的！
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法（局限性）
        Person s2 = new Student();
        Person s3 = new Person();
        Object s4=new Student(); //Object类是所有类的“祖宗”

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
        s1.eat(); //子类生成的子类对象(实例)，可以调用子类中的所有方法
        s1.run(); //子类生成的子类对象，可以调用子类中的所有方法
        s1.sleep();//子类生成的子类对象，调用继承父类的方法
        s2.run(); //借用子类生成的父类对象，只能调用子类重写父类的方法
        s2.sleep(); //或者调用父类中定义的方法（没有被子类重写）
        //s2.eat(); 不可执行。借用子类生成的父类对象，不能调用父类中不存在的方法
        s3.run(); //父类生成的父类对象，调用父类中的方法
    }
}

多态的注意事项：
①多态是方法的多态，属性没有多态
②父类和子类，有联系 类型转换异常 ClassCastException
③存在条件：继承关系、方法需要重写、父类引用指向子类对象。Father f1 =new Son();
其中不能被重写的方法有：
static方法，属于类，它不属于实例；final常量；private方法；

（2）instanceof（判断一个对象是什么类型）

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

    public void sleep(){
        System.out.println("人sleep");
    }
}
public class Student extends Person {
    public void run(){
        System.out.println("学生run"); //重写了父类的run()方法
    }

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

public class Teacher extends Person{
}
public class Application {
    public static void main(String[] args) {



        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student

        Object ob =new Student();
        System.out.println(ob instanceof Student); //true
        System.out.println(ob instanceof Person);  //true
        System.out.println(ob instanceof Object); //true
        System.out.println(ob instanceof Teacher); //false
        System.out.println(ob instanceof String);  //false

        System.out.println("=================");

        Person pe =new Student();
        System.out.println(pe instanceof Student); //true
        System.out.println(pe instanceof Person);  //true
        System.out.println(pe instanceof Object); //true
        System.out.println(pe instanceof Teacher); //false
        //System.out.println(pe instanceof String);  //编译就报错

        System.out.println("=================");

        Student st = new Student();
        System.out.println(st instanceof Student); //true
        System.out.println(st instanceof Person);  //true
        System.out.println(st instanceof Object); //true
        //System.out.println(st instanceof Teacher); //编译就报错,因为和Teacher不在一条继承链上（二者没有任何关系）
        //System.out.println(st instanceof String);  //编译就报错，因为和String不在一条继承链上（二者没有任何关系）
    }
}

/*
1、比如Person X = new Student()，我们知道左边Person是引用类型，右边Student是实际类型
2、X instanceof Y，然后看X的类型（就是引用类型Person）和Y有没有继承关系，没有就直接报错，有就下一步
3、然后判断X的实际类型（就是右边的Student），是不是Y本身或者他的子类，是就true，不是就false
4、注意的是实际类型不能是Y的父类，不然就会false
 */

7.static关键字

8.抽象类

//abstract 抽象类
public abstract class Action {

    //约束，有人帮我们实现
    //abstract,抽象方法，只有方法名字，没有方法的实现
    public abstract void doSomething();

    /*
    1. 不能new这个抽象类，只能靠子类去实现它：约束！
    2. 抽象类中可以写普通方法
    3. 抽象方法必须在抽象类中
    //抽象的抽象：约束！
     */

}

//abstract 抽象类，单继承    （接口可以多继承）
//抽象类的所有方法，继承了它的子类，都必须要实现它的方法
public class A extends Action{

    @Override
    public void doSomething() {

    }
}

9.接口

（1）接口实现-小例子

//抽象的思维- java 架构师，把系统完成抽象成接口

//interface 定义的关键字，接口都需要有实现类
public interface userService {
    //接口中的所有定义其实都是抽象的 public abstract

    int AGE =99;

    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

public interface timeService {
    void timer();
}

//抽象类： extends
//类  可以实现接口 implement 接口
// 实现了接口的类，就需要重写接口中的方法

// 多继承，利用接口实现多继承
public class userServiceImpl implements userService,timeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

（2）接口的作用

  ①约束
  ②定义一些方法，让不同的人实现
  ③public abstract
  ④public static final
  ⑤接口不能被实例化，接口中没有构造方法
  ⑥implements可以实现多个接口
  ⑦必须要重写接口中的方法

10.内部类