Java的抽象类和接口

回顾昨天的内容

         public class student {
             private static int age;//静态的变量  多线程！
             private double score;//非静态的变量

          public void run(){
          }
          
          public static void go(){
          }

          public static void main(String []args){
                student.go();
}
            
}

       public class text1 {
               
              // 2、
              {
                System.out.println("匿名代码块");
              }
             // 1、最先被输出，但是第二次开始就不会被输出
              static {
                 System.out.println("静态代码块")
                     }
               //3、
              public person{
                 System.out.println("构造方法")

}
            public static void main(String [] args)
            {
                 Person person1 = new person();
                 System.out.println("=================")
                 Person person2 = new person();
            }
       }

     // 静态导入包

        import static java.lang.Math.random;
        import static java.lang.Math.PI;

        public class text2{
             public static void main(String [] args){
                  System.out.println(Math.random());
                  System.out.println(Math.PI());
                  System.out.println(random());
                  System.out.println(PI());
                  
}
}

抽象类

1、abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类

2、抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类

3、抽象类，不能使用new关键字来创建对象，它是用来让子类继承的

4、抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的

5、子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

     //abstract 抽象类 ：类 extends 单继承~ （接口可以多继承）
    public abstract class text3{
             
          //约束~有人帮我们实现~
          //abstract 抽象方法只有方法名字，没有方法的实现！
           
          public abstract void dosomething();

}

     //抽象类的所有方法，继承了它的子类，都必须要实现它的方法~除非它的子类也是抽象类
    public abstract  class A extends text3{
          
          public abstract void dosomething(){
     
   } 
          

}

抽象类
1、不能new这个抽象类，只能靠子类去实现它；约束！
2、抽象类里面可以写普通方法。
3、抽象方法必须在抽象类中~
抽象的抽象：约束~

接口

1、普通类：只有具体实现

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

3、接口：只有规范！ 自己无法写方法~

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

5、接口的本质是契约，就像我们人间的法律英语。制定好后大家都遵守

6、OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计 模式都只针对具备了抽象能力的语言（比如C++、java、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象
！
声明类的关键字是class，声明接口的关键字是interface

        //抽象思维~ Java
       //interface 定义的关键字，接口都需要有实现类
       public interface S1{
        //常量~ public static final

        int AGE = 99;

        //接口中的所有定义其实都是抽象的 public abstract 
      void add(String name);
      void delete(String name);
      void update(String name);
      void query(String name);

}

  //抽象类：extends~
  //类 可以实现接口 implements 接口
  //实现了接口的类，就需要重写接口中的方法~
      public class S2 implements S1,S3{
       }
       
       public void add(String name){
       }
       
       public void add(String name){
       }
       
       public void add(String name){
       }
       
       public void add(String name){
       }
       public void tmer(){
       }
}

    public interface S3{
      void timer();
}

作用：
1、约束
2、定义一些方法，让不同的人实现~ 10 —> 1
3、接口的默认方法： public abstract
4、常量定义：public static final
5、接口不能实例化~，接口中没有构造方法
6、implements可以实现多个接口
7、必须要重写接口中的方法！