抽象类

  1. /*
  2. 通过abstract定义的方法是抽象方法，它只有定义，没有实现。抽象方法定义了子类必须实现的接口规范；
  3. 定义了抽象方法的class必须被定义为抽象类，从抽象类继承的子类必须实现抽象方法；
  4. 如果不实现抽象方法，则该子类仍是一个抽象类；
  5. 面向抽象编程使得调用者只关心抽象方法的定义，不关心子类的具体实现。
  6. */
  8. public class Object1{
  9.     public static void main(String[] args) {
  10.         Person p = new Student();
  11.         p.run();
  12.     }
  13. }
  15. // abstract修饰的类叫抽象类
  16. abstract class Person{
  17.     public abstract void run();  // 抽象方法
  18. }
  20. class Student extends Person{
  21.     @Override
  22.     public void run() {
  23.         System.out.println("Student.run");
  24.     }
  25. }

接口

  1. // 抽象类与接口的对比
  3.                     abstract class                 interface
  4.      继承             只能extends一个class       可以implements多个interface
  5.      字段             可以定义实例字段              不能定义实例字段
  6.      抽象方法        可以定义抽象方法            可以定义抽象方法
  7.      非抽象方法       可以定义非抽象方法           可以定义default方法
  9. // 接口的继承
  10. interface Hello {
  11.     void hello();
  12. }
  14. interface Person extends Hello {
  15.     void run();
  16.     String getName();
  17. }
  19. // default方法
  20. public class Object1{
  21.     public static void main(String[] args) {
  22.         Person p = new Student("xiao wang");
  23.         p.run();
  24.     }
  25. }
  27. interface Person{
  28.     String getName();  // 可以省略前面修饰的public abstract
  29.     /*
  30.     * default方法的目的是，当我们需要给接口新增一个方法时，会涉及到修改全部子类。
  31.     * 如果新增的是default方法，那么子类就不必全部修改，只需要在需要覆写的地方去覆写新增方法。*/
  32.     default void run() {
  33.         System.out.println(getName() + " run");
  34.     }
  35. }
  37. // 实现接口需要用到implements关键字，
  38. // 一个类可以实现多个接口class Student implements Person Hello{
  39. class Student implements Person {
  40.     private String name;
  42.     public Student(String name){
  43.         this.name = name;
  44.     }
  46.     public String getName(){
  47.         return this.name;
  48.     }
  49. }

静态字段和静态方法

  1. // 静态字段实例
  2. public class Object1{
  3.     public static void main(String[] args) {
  4.         Person p = new Person("小王",21);
  5.         Person m = new Person("小帅",24);
  7.         //p.number = 100;
  8.         //System.out.println(p.number);
  9.         //m.number = 1000;
  10.         //System.out.println(m.number);
  11.         /*
  12.          * 通过演示我们发现 实例变量.静态字段 能够去访问静态字段；实例变量并没有该字段，
  13.          * 这是因为编译器会根据实例类型自动转换为 类名.静态字段 来访问静态对象
  14.          * 因此，建议直接用 类名.静态字段 来访问静态对象*/
  15.         Person.number = 100;
  16.         System.out.println(Person.number);
  17.     }
  18. }
  20. class Person{
  21.     public String name;
  22.     public int age;
  24.     public static int number;  // 静态字段
  26.     public Person(String name, int age){
  27.         this.name = name;
  28.         this.age = age;
  29.     }
  30. }
  32. // 静态方法
  33. // 调用静态方法不需要实例，无法访问this，但可以访问静态字段和其他静态方法；
  34. public class Object1{
  35.     public static void main(String[] args) {
  36.         Person.setNumber(100);
  37.         System.out.println(Person.number);
  38.     }
  39. }
  41. class Person{
  42.     public static int number;
  44.     // 用static修饰的方法称为静态方法
  45.     public static void setNumber(int value){
  46.         number = value;
  47.     }
  48. }
  50. // 接口的静态字段
  51. // 接口不能定义实例字段。但是可以有静态字段
  52. public interface Person {
  53.     //public static final int MALE = 1;
  54.     //public static final int FEMALE = 2;
  55.     // 编译器会自动加上public statc final:
  56.     int MALE = 1;
  57.     int FEMALE = 2;
  58. }