JAVA类、接口、继承、回调的概念与实现

声明

本人在学习过程中有借鉴网络上的内容，加之自己的理解和总结故成此文

一、Java类

类的概念

类：类是一个模板，它描述一类对象的行为和状态。
类包括：
属性：对象数据的描述
方法：对象的行为
构造方法：用于实例化对象
内部类：在类中声明的类

public class Puppy {
    int puppyAge;//属性

    //构造方法
    public Puppy(String name) {
        System.out.println("小狗的名字是: " + name);
    }

    //方法
    public void setAge(int age) {
        puppyAge = age;
    }
    //内部类
    class dog{
        String name;
        int age;
    }
    public static void main(String[] args) {
        //创建对象
        Puppy myPuppy = new Puppy("tommy");
        myPuppy.setAge(2);

    }
}

Java类中变量类型的比较

成员变量：
1、成员变量定义在类中，在整个类中都可以被访问。
2、成员变量随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中。
3、成员变量有默认初始化值。
局部变量：
1、局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。
2、局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放。
3、局部变量没有默认初始化值

class People {
    String name = "成员变量的name";

    People() {
    }

    public void speak() {
        String name = "局部变量的name";
        System.out.println(name);
        System.out.println(this.name);
    }

    public void speak2() {
        System.out.println(name);
    }
}

class TestThis {
    public static void main(String[] args) {
        People myPeople = new People();
        myPeople.speak();
        myPeople.speak2();
    }
}

成员变量和类变量的区别：

1、两个变量的生命周期不同

  成员变量随着对象的创建而存在，随着对象的回收而释放。

  静态变量随着类的加载而存在，随着类的消失而消失。

2、调用方式不同

  成员变量只能被对象调用。

  静态变量可以被对象调用，还可以被类名调用。

3、数据存储位置不同

  成员变量存储在堆内存的对象中，所以也叫对象的特有数据。

  静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

class MyAdd {
    int count = 0;
    //成员变量
    static int sum = 0;
    //静态变量
    String name;

    MyAdd(String name) {
        this.name = name;
    }

    public void myAddMethod() {
        count++;
        System.out.println(name + "调用成员变量后的值: " + count);
    }

    public void staticAddMethod() {
        sum++;
        System.out.println(name + "调用类后变量的值: " + sum);
    }
}

class TestThis {
    public static void main(String[] args) {
        MyAdd add1 = new MyAdd("add1");
        MyAdd add2 = new MyAdd("add2");
        add1.myAddMethod();
        add2.myAddMethod();
        add1.myAddMethod();
        add1.staticAddMethod();
        add2.staticAddMethod();
        add1.staticAddMethod();
    }
}

二、接口

接口（Interface）是一个抽象类型，是抽象方法的集合。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

接口无法被实例化，但是可以被实现。

关于抽象类

1、抽象方法：只有声明，而没有具体的实现。声明格式为：abstract void fun();
2、抽象类：如果一个类含有抽象方法，则称这个类为抽象类，抽象类必须在类前用 abstract 关键字修饰。因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。但它和普通类一样，同样可以拥有成员变量和普通的成员方法。
3、关于抽象类的继承：如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为 abstract 类。
4、抽象类中的变量和方法：它和普通类一样，同样可以拥有成员变量和普通的成员方法。

抽象类和接口

1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。

2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。

3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。

4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口

接口与类的区别：

接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法，Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

抽象类可以继承抽象类。在一个类继承了某个抽象方法后，如果没有实现该父类中的所有抽象方法，这个类便还是一个抽象类

抽象类可以实现接口。接口用于定义功能,抽象类用于定义模板方法。当使用抽象类实现接口时不需要实现所有的接口，只实现自己所需的接口就可以。

三、 继承

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

父类更通用，子类更具体。子类会具有父类的一般特性也会具有自身的特性。

继承的特性

1、子类拥有父类非 private 的属性、方法。

2、子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

3、子类可以用自己的方式实现父类的方法。

4、Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。

5、提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

extends

extends 在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

implements

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

一个关于继承的问题

public class Demo {
    static Demo demo = new Demo();
    class A{
        public int x = 1;
        public int testX(){
            System.out.println("父类方法");
            return x;
        }
    }
    class B extends A{
        public int x = 2;
        public int testX(){
           System.out.println("子类方法");
            return x;
        }
    }
    public static void main(String []args){
        A a = demo.new B();
        System.out.println(a.x);
        System.out.println(a.testX());
    }
}

这段代码中的A，称为静态类型或外观类型。
而B称为实际类型。a本身的静态类型不会被改变，且最终的静态类型在编译期是可知的。
而它的实际类型可以改变，其变化的结果在运行期才可以确定，在编译期变量的实际类型是不可知的。
这就导致a具有父类A的属性，但在子类方法复写父类方法的情况下调用子类的方法。

四、回调

回调分为同步回调和异步回调
假如以买彩票的场景来模拟。
我买彩票, 调用彩票网,给我返回的结果确定是否中奖,
同步回调就是,我买了彩票之后, 需要等待彩票网给我返回的结果, 这个时候我不能做其他事情, 我必须等待这个结果,
异步回调就是, 我买了彩票之后, 可以去做其他事情, 然后当彩票网有了结果和消息, 再给我返回消息,
其中最明显的方式就是在得到彩票结果的函数之中, 添加一个其他的方法, 如果我的其他方法可以立即执行, 那么就是异步的(给出是否中奖需要花费很长的时间),