2021-05-21

抽象类

• abstract 修饰符可以用来修饰方法也可以修饰类，修饰方法就事抽象方法，修饰类就是抽象类。

• 抽象类中可以没有抽象方法，可以有普通方法

• 抽象方法必须在抽象类中

  package com.zhangyu.OOP.Demo08;
  //abstract :抽象类   类  extends  单继承    接口可以多继承
  public  abstract class Action {
      //约束 有人帮我们实现
      //abstract 抽象方法，只有方法名字  没有方法的实现！
      public abstract void doSomething();
      //1. 不能new这个抽象类   只能靠子类去实现它
      //2.存在的意思   提高开发效率  简化代码 
  }
  

package com.zhangyu.OOP.Demo08;
//抽象类的所有方法，继承了他的子类，都必须实现他的方法~~~~
//public abstract class a extends Action  除非子类也是抽象方法
public abstract class a extends Action {
    @Override
   public void doSomething() {

    }

}

接口

• 普通类：只有具体实现

• 抽象类：具体实现和规范（抽象方法）都有

• 接口：只有规范 自己无法写方法 专业的约束！ 约束和实现分离：面向接口编程

• 接口就是规范，定义的是一组规则，体现了显示中“如果你是…则必须能…”的思想，如果你是天使则必须能飞。

• 接口的本质就是契约，制定好大家都遵循

• OO的精髓，是对对象的抽象，最能体现这一点的就是接口。因为设计模式所研究的，实际就是如何合理的去抽象。

​ 声明类的关键字是class，声明接口的关键字数interface

package com.zhangyu.OOP.Demo09;

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

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

package com.zhangyu.OOP.Demo09;
//抽线类 extends
//类 可以实现接口  implements 接口
//实现了接口的类，就需要重写接口中的方法
//利用接口对实现多继承   只有通过interface 来定义方法
public class UserServiceImpImpl 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 time() {

    }
}

package com.zhangyu.OOP.Demo09;

public interface TimeService {
    void time();
}

• 作用：
  • 约束
  • 定义一些方法，让不同的人实现
  • public abstract
  • public static final
  • 接口不能被实例化 接口中没有构造方法
  • 必须重写接口的方法

内部类

内部类就是一个类的内部定义一个类

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

package com.zhangyu.OOP.Demo10;

public class Outer {

    private int id;
     public void out(){
        System.out.println("这是外部类的方法");
    }
    public  class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获取外部类的私有属性
        public  void getID(){
            System.out.println(id);
        }
    }
}
package com.zhangyu.OOP;
import com.zhangyu.OOP.Demo06.Person;
import com.zhangyu.OOP.Demo06.Student;
import com.zhangyu.OOP.Demo06.Teacher;
import com.zhangyu.OOP.Demo08.Action;
import com.zhangyu.OOP.Demo10.Outer;

import java.util.Scanner;
public class Application {
    public static void main(String[] args) {
        //new
        Outer outer = new Outer();
        //通过外部类来实例化内部类

        outer.out();
        //通过 outer.new Inner
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();






    }
}

package com.zhangyu.OOP.Demo10;

public class Test {
    public static void main(String[] args) {
//        Apple apple = new Apple();
//        apple.eat();
        //没有名字初始化类，不用讲实列保存道变量中
        new Apple().eat();
        UserService userService = new UserService() {
            @Override
            public void hello() {


            }

        };


    }

}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}
interface UserService{
    void hello();


}