mt_Day6:oop进阶

导包

• 同一个包下的类可直接访问

• 不同包下的类，必须先导包才能访问

• 如果这个类中使用不同包下的相同类名，此时默认只能导入一个类的包，另一个类使用全名访问

import com.xuexi.d1_package.it1.Student;//import 包名.类名

import java.util.Scanner;

public class test {
    public static void main(String[] args) {
        //1.同一个包下的类可直接访问
        System.out.println(User.onlineNum);

        //2.不同包下的类，必须先导包才能访问
        Student s=new Student();
        Scanner sc=new Scanner(System.in);

        //3.如果这个类中使用不同包下的相同类名，此时默认只能导入一个类的包，另一个类使用全名访问
        com.xuexi.d1_package.it2.Student s2=new com.xuexi.d1_package.it2.Student();
    }
}

权限修饰符

• 控制一个成员能够被访问的范围
• 作用范围由小到大：private—缺省—protected—public

final

• final关键字是最终的意思，可修饰（类、方法、变量）
• 修饰类：该类是最终类，不能被继承
• 修饰方法：该方法是最终方法，不能被重写
• 修饰变量：该变量第一次赋值后，不能再次被赋值（有且仅能被赋值一次）

常量

• public static final修饰，必须有初始化值，执行过程中值不能被改变

执行原理

• 编译阶段进行宏替换，把使用常量的地方全部替换成真实的字面量
• 好处：让使用常量的程序的执行性能与直接使用字面量是一致的

枚举

public enum Season {
    SPRING,SUMMER,AUTUMN,WINTER;
}

//反编译
public final class Season extends java.lang.Enum<Season> {
  public static final Season SPRING;
  public static final Season SUMMER;
  public static final Season AUTUMN;
  public static final Season WINTER;
  public static Season[] values();
  public static Season valueOf(java.lang.String);
  static {};
}

枚举特征

• 枚举类都继承了枚举类型：java.lang.Enum
• 枚举类都是最终类，不能被继承
• 枚举类的构造器都是私有的，不能创造对象
• 枚举类的第一行默认都是罗列枚举对象的名称的
• 相当于是多例模式

抽象类

/**
 * 抽象类
 */
public abstract class Animal {
    /**
     * 抽象方法
     */
    public abstract void run();
}

public class Dog extends Animal{
    @Override
    public void run() {
        System.out.println("狗跑得快");
    }
}

• 抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
• 得到抽象方法，失去创造对象的能力，why？若可以创建对象a, a.run()不能执行

final与abstract的关系

• 互斥
• 抽象类作为模板让子类继承，final定义的类不能被继承
• 抽象方法定义通用功能让子类重写，final定义的方法不能重写

接口

/**
 * 声明一个接口：体现一种规范，所以一定是要公开的,public可省略
 */
public interface interfaceDemo {
    //JDK1.8前，只能有常量、抽象方法
    //1.常量
   // public static final String SCHOOL_NAME="小学";
    String SCHOOL_NAME="小学";
    //2.抽象方法
    //public abstract void test1();
    void test1();
    //public abstract void test2();
    void test2();
}

接口的实现

public interface SportMan {
    void run();
    void competition();
}

public interface Law {
    void rule();
}

//实现SportMan和Law接口
public class PingPangMan implements SportMan,Law{
    private String name;
    public PingPangMan(String name){
        this.name=name;
    }
    @Override
    public void run() {
        System.out.println(name+"早7：00跑步");
    }

    @Override
    public void competition() {
        System.out.println(name+"参加乒乓球比赛");
    }

    @Override
    public void rule() {
        System.out.println("遵守乒乓规则");
    }
}

• 类和类的关系：单继承
• 类和接口的关系：多实现，一个类可实现多个接口
• 接口和接口的关系：多继承，一个接口可同时继承多个接口

多接口继承作用

• 规范合并，整合多个接口为一个接口，便于子类实现

  public interface SportMan extends Law,people {
      void run();
      void comptetion();
  }
  

JDK8新增接口方法（很少用）

public interface SportmanInterface {
    /**
     * 1.JDK8开始：默认方法（实例方法）
     * --必须用default修饰，默认有public
     * --默认方法，不能创建对象，只能过继给实现类，由实现类对象调用
     */
    default void run(){
        System.out.println("跑步训练");
    }
}
class PingPangSportman implements SportmanInterface{
}   //接口没有抽象方法，不用重写
class test1{
    public static void main(String[] args) {
        PingPangSportman s=new PingPangSportman();
        s.run();
    }
}

接口注意事项

1. 接口不能创建对象（接口更加彻底的抽象）
2. 一个类实现多个接口，多个接口有同样的静态方法不冲突（因为static方法只能用方法名调用，不用担心冲突）
3. 一个类继承了父类，同时又实现了接口，父类和接口中有同样的方法，默认用父类的
4. 一个类实现了多个接口，多个接口中存在同名默认方法，不冲突，这个类重写该方法即可（即不用接口的，自己重写一个就不会报错）
5. 一个接口继承多个接口，没有问题，如果多个接口中存在规范冲突，则不能继承（如：【接口1：void run() 】【接口2：int run()】,不能一起继承，一样就可以）