OOP的补充知识

原文链接

抽象类

1. abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法;如果修饰类，那么该类就是抽象类。
2. 抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
3. 抽象类,不能使用new关键字来创建对象, 它是用来让子类继承的。
4. 抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
5. 子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法, 否则该子类也要声明为抽象类。

//abstract 抽象类， 是一个约束
public abstract class Action {

    public Action() {
    }

    //抽象的方法可以只有方法名，没有方法实现
    public abstract void doSomething();

}
/*
类都是用extends继承，而类只能单继承，但是接口可以多继承
1. 不能new这个抽象类，只能靠子类去实现它;约束!
2. 抽象类中可以写普通的方法~
3. 抽象方法必须在抽象类中~
4.抽象的抽象:约束~
5.思考题?  存在构造器么?  抽象类也存在构造器
6.存在的意义抽象出来~ 提高开发效率
 */

//如果一个父类是一个抽象类，继承了它的子类，都必须要实现它的方法
// 除非它的子类也是一个抽象类，那就要它的子子类去实现它的方法
public class A extends Action {
    @Override
    public void doSomething() {

    }
}

接口

1. 普通类:只有具体实现

2. 抽象类:具体实现和规范(抽象方法)都有!

3. 接口:只有规范! 自己无法写方法~专业的约束!约束和实现分离:面对接口编程

4. 接口就是规范，定义的是一组规则，体现了现实世界中“如果你…则必须能.的思想。如果你是天使，则必须能飞。如果你是汽车,则必须能跑。如果你好人，则必须干掉坏人;如果你是坏人，则必须欺负好人。

   接口的本质是契约,就像我们人间的法律一样。制定好后大家都遵守。

   oo的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言(比如c++. java、 c#等) ，就是因为设计模式所研究的，实际上就是如何合理的去抽象。

定义一个UserService接口

//接口定义的关键字：interface ,接口都需要有实现类
public interface UserService {

    //默认为常量，public static final
    public static final int age = 99;  //一般不在接口定义常量，都是定义方法


    //接口中的所有定义的方法其实都是抽象的， 默认就是public abstract,可以直接忽略不写
    public abstract void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

再定义一个TimeService接口

public interface TimeService {
    void timer();
}

用implements实现多继承

//抽象类：extends
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法
//多继承：利用接口实现多继承
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() {

    }
}

总结：

1. 接口中的方法默认为public abstract
2. 接口中的常量默认为public static final
3. 接口不能被实例化，接口中没有构造方法
4. implements 可以实现多个接口
5. 继承了接口的类，就必须要重写接口中的方法~

内部类

1. 内部类就是在一个类的内部在定义一个类,比如，A类中定义一个B类,那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
2. 成员内部类

​ 先定义一个外部的类，再在里面定义一个内部的类

public class Outer {

    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }

    public class  Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }

        //可以获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }
}

先实例化外部的类，再通过外部的类实例化内部的类

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.out();//这是外部类的方法
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();//这是内部类的方法
        inner.getID();//10

    }
    }

3. 静态内部类

   加static

4. 局部内部类

 //局部内部类
    public void method(){
        class Inner1{
            public void in1(){

            }
        }
    }

5. 匿名内部类

   可以不用写类名也是可以的

6. 一个java类中可以有多个class类，但只能有一个public class类，还可以在类中定义接口