Java 入门 26 包导入 权限修饰符 final 常量 枚举 抽象类 接口

demo1下的Cat类

package com.ITheima.op_object.demo1;

public class Cat {
    public void run(){
        System.out.println("demo1下的cat");
    }
}

demo2下的Cat类

package com.ITheima.op_object.demo2;

public class Cat {
    public void run() {
        System.out.println("demo2下的cat");
    }
}

Test类

package com.ITheima.op_object;

import com.ITheima.d9_extends.Animal;
import com.ITheima.op_object.demo1.Cat;

public class Test {
    public static void main(String[] args) {
       //导包:相同报下的类可以直接访问
        Student s=new Student();

        //不同包下的类必须导包才可以使用
        Animal a=new Animal();

        //使用默认导包下的demo下的car
        Cat c1=new Cat();

        //相同包名不同目录下的包则 必须全部写完成
        com.ITheima.op_object.demo2.Cat c2=new com.ITheima.op_object.demo2.Cat();

        c1.run();
        c2.run();
    }
}

 权限修饰符

 itcast包下的两个类

Fu类

package com.ITheima.d1_modifier.itcast;

public class Demo  {
    public static void main(String[] args) {
        //同一个类中 除了私有权限不能访问  其他权限都可以访问
        Fu f=new Fu();
        f.show2();
        f.show3();
        f.show4();
    }
}

Demo类(普通类) 可以调用 缺省  ,protected,public三个权限方法

package com.ITheima.d1_modifier.itcast;

public class Demo  {
    public static void main(String[] args) {
        //同一个类中 除了私有权限不能访问  其他权限都可以访问
        Fu f=new Fu();
        f.show2();
        f.show3();
        f.show4();
    }
}

itheima包下的两个类

Zi类(继承Fu的子类) 可以调用 protected,public两个权限方法

package com.ITheima.d1_modifier.itheima;

import com.ITheima.d1_modifier.itcast.Fu;

public class Zi extends Fu {
    public static void main(String[] args) {
        //创建Zi的对象,测试看有哪些方法可以使用
        Zi z=new Zi();

        z.show3();
        z.show4();
    }
}

Demo(普通类) 只可以调用 public权限方法

package com.ITheima.d1_modifier.itcast;

public class Demo  {
    public static void main(String[] args) {
        //同一个类中 除了私有权限不能访问  其他权限都可以访问
        Fu f=new Fu();
        f.show2();
        f.show3();
        f.show4();
    }
}

 

 final的作用

package com.ITheima.Final;

/**
 * 目标:明白final一些基本语法
 */
public class Test {
    //属于类 只加载一次 可以共享(常量)

    public static final  String schoolName="黑马";

    public static final String schoolName1;

    static{
        schoolName1="船只";
//        schoolName1="飞机";//已经赋值玩一次  在赋值第二次 报错
    }

    public static void main(String[] args) {
//        schoolName="船只";//赋值一次 在赋值 报错


        //final修饰变量,变量有且仅能被赋值一次
        /**
         * 变量有几种j
         *局部变脸
         *成员变量
         * -----1静态成员变量
         * -----2 实例成员变脸
         */
        final  int age;
        age=12;
        //age=22; //第二次赋值 报错了

        final double rate=3.14;

        buy(0.8);
    }

    private static void buy(final double z) {
//        z=0.1;//第二次赋值 报错了
    }
}

/**
 * 1 final修饰类 类不能被继承了
 */

//final class Animal{
//
//}
//class Cat extends Animal{
//
//}


/*
 * final 修饰方法 ,方法不能被重写了
 *
 * */
class  Animal{
    public  final void run(){
        System.out.println("动物可以跑");
    }
}


class Tiger extends Animal{
//    @Override
//    public void run(){
//        System.out.println("老虎跑的块");
//    }
//
//    public static void main(String[] args) {
//        Tiger t=new Tiger();
//        t.run();
//    }
}

package com.ITheima.Final;

public class Test1 {
    public static void main(String[] args) {
       //final修饰变量的注意事项
       //1 final修饰基本类型变量,其数据不能在改变
        final double rate=3.14;
//        rate=1;//final定义的基本数据类型 只能赋值一次  在赋值就会报错
        System.out.println(rate);

        //2 final修饰的引用数据类型的变量,变量中存储的地址不能改变,但是地址只想的对象内容可以该改变
        final int[] arr={10,20,30};
        // arr=null;//输入第二次赋值  arr是数组 引用类型 引用地址不可以改变 ,arr内的成员值可以改变
        System.out.println(arr);
        arr[1]=100;
        System.out.println(arr);
        System.out.println(arr[1]);
    }
}

常量

package com.ITheima.Final;

/**
 * 目标:学会常量的使用,并理解常量
 */
public class Const {
    //定义常量
    public static final String SCHOOL_NAME="船只教育";
    public static final String USER_NAME="admin";
    public static void main(String[] args) {
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);


        if(USER_NAME.equals("")){

        }
    }
}

枚举

 

 抽象类

Animal抽象类 

package com.ITheima._abstract_class;


/**
 * 抽象类 定义的方法
 * 继承抽象类的子类必须重写该方法
 */
public abstract class Animal {
    private String name;
    public abstract void run();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Tiger(继承Animal的子类)

package com.ITheima._abstract_class;


public class Tiger extends Animal{
    @Override
    public void run() {
        System.out.println("老虎跑到 真快");
    }
}

Test类

package com.ITheima._abstract_class;

public class Test {
    public static void main(String[] args) {
        Tiger t=new Tiger();
        t.run();
    }
}

 案例

 AllCards 抽象类

package com.ITheima.SystemNeed;

public abstract class AllCards {
    private String name;
    private double money;
    public abstract void pay(double money);

    //get set
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

JCards 金卡 继承AllCards抽象类

package com.ITheima.SystemNeed;

public class JCards extends AllCards{
    public static void main(String[] args) {

    }

    @Override
    public void pay(double money){
        //优惠后的金额
        double rs=money*0.8;
        double lastMoney=getMoney()-rs;
        //更新账户对象金额
        System.out.println(getName()+"当前金额: \t"+"消费"+rs+"剩下余额"+lastMoney);
        setMoney(lastMoney);
    }
}

YCards银卡 继承AllCards抽象类

package com.ITheima.SystemNeed;

public class JCards extends AllCards{
    public static void main(String[] args) {

    }

    @Override
    public void pay(double money){
        //优惠后的金额
        double rs=money*0.8;
        double lastMoney=getMoney()-rs;
        //更新账户对象金额
        System.out.println(getName()+"当前金额: \t"+"消费"+rs+"剩下余额"+lastMoney);
        setMoney(lastMoney);
    }
}

Test测试类

package com.ITheima.SystemNeed;

public class Test {
    public static void main(String[] args) {
        JCards j=new JCards();
        j.setName("丁蕾");
        j.setMoney(10000);
        j.pay(300);

        YCards y=new YCards();
        y.setName("张三");
        y.setMoney(10000);
        y.pay(500);

    }
}

 

final 与abstract的关系

 

_案例

 

 Account 银行类 抽象类  模板方法

package com.ITheima.Bank;

public abstract class Account {
    private String cardId;
    private double money;

    //无参构造器

    public Account() {
    }

    //有参构造器

    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }

    /**
     * 模板方法
     *
     */
    public final void handle(String loginName,String password){
        //1 判断是否登录成功
        if("itheima".equals(loginName) && "123456".equals(password)){
            System.out.println("登录成功");
            //2 正式结算利息(当前模板方法私有子类账户都要结算利息,但是具体怎么算模板不清楚 交给具体的子类来计算)
            double result=calc();

            System.out.println("本账户利息:"+result);
        }else{
            System.out.println("用户名账户或密码错误");
        }
    }

    //抽象方法
    public abstract double calc();

    //set get

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

CurrentAccount继承Account抽象类 

package com.ITheima.Bank;

/**
 * 活期利息
 */
public class CurrentAccount extends  Account{
    public CurrentAccount(String cardId,double money){
        super(cardId,money);
    }

    @Override
    public double calc(){
        //整数结算利息
        double result=getMoney()*0.0175;//结算利息了
        return result;
    }
}

Test 类

package com.ITheima.Bank;

public class Test {
    public static void main(String[] args) {
        CurrentAccount acc=new CurrentAccount("123230",10000);
        acc.handle("itheima","123456");
    }
}

 接口 

 

 SportManInterface 接口

package com.ITheima._Interface;

/**
 * 接口
 */


public interface SportManInterface {
    //接口中的成员:JDK 1.8之前只有常量和抽象方法

    //1public static final 可以省略不屑 ,接口默认会为你加上
    //public static final String SCHOOL_NAME="黑马";
    String SCHOOL_NAME="黑马";

    //2 抽象方法
    //public abstract 可以省略不屑,接口会默认为你加上
    //public abstract void run();
    void run();


    //public abstract void eat();
    void eat();
}

Test测试类(接口不能实例化)

package com.ITheima._Interface;

public class Test {
    public static void main(String[] args) {
        //接口不能创建对象
        //SportManInterface s=new SportManInterface();

    }
}

 SportMan 接口

package com.ITheima._Interface;

public interface SportMan {
    //跑步
    void run();
    //比赛
    void competition();
}

Law 接口

package com.ITheima._Interface;

public interface Law {
    //遵守法律
    void rule();
}

PingPongMan类实现SportMan,Law接口

package com.ITheima._Interface;

/**
 * 实现类(是一种哦特殊的子类)
 */

/**
 * implements 实现
 * alt+回车键 选中 重写方法
 */
public class PinPongMan implements Law, SportMan {
    private  String name;

    //无参构造器

    public PinPongMan() {
    }


    //有参构造器


    public PinPongMan(String name) {
        this.name = name;
    }

    //get set


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void rule() {
        System.out.println("遵纪守法");
    }

    @Override
    public void run() {
        System.out.println("参加跑步训练");
    }

    @Override
    public void competition() {
        System.out.println("需要参加比赛");
    }
}

Test测试类

package com.ITheima._Interface;

public class Test {
    public static void main(String[] args) {
        PinPongMan p=new PinPongMan("张继科");
        p.run();
        p.competition();
        p.rule();
    }
}

 接口 多继承

Law类

package com.ITheima._interface12;

public interface Law {
    void rule();
}

Person类

package com.ITheima._interface12;

public interface Person {
    void eat();
}

SportMan继承 Law ,Person接口

package com.ITheima._interface12;

/**
 * SportMan 继承Law,Person类
 */
public interface SportMan extends Law,Person {
    void run();
    void competition();
}

BasketBallMan类实现 SportMan接口

package com.ITheima._interface12;

/**
 * 接口多继承
 */
public class BasketBallMan implements SportMan{
  private String name;

  public BasketBallMan() {
  }

  public BasketBallMan(String name) {
    this.name = name;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  @Override
  public void rule() {

  }

  @Override
  public void eat() {

  }

  @Override
  public void run() {

  }

  @Override
  public void competition() {

  }
}

 如果 接口 规范冲突  就不能多继承

 

 

 

package com.ITheima._interface1;



public interface SportManInter {
    /**
     * 1 JDK 8开始 : 默认方法(实例方法)
     * ----必须default 修饰,默认用public修饰
     * ----默认方法,接口不能创建对象,这个方法只能过继给了实现类,由实现类对象调用
     * (个人理解 就是 default +方法 放在接口中  ,由类实现接口后 可以直接调用 不需要在重写)
     */

    default  void run(){
        go();
        System.out.println("跑的很快");
    }

    /**
     * 2 静态方法
     * 必须使用static修饰,默认用public修饰
     * -----接口的静态方法,必须接口名自己调用
     */
     static void inAddr(){
         System.out.println("我们都在学习java");
     }

    /**
     * 3 私有方法
     * ----JDK1.9开始才支持
     * ----必须在接口内部才能被访问
     */
    private void go(){
        System.out.println("开始跑~~~~~~");
    }
}

//接口实现
class PingPongMan implements SportManInter{

}

//测试类
class Test{
    public static void main(String[] args) {
        PingPongMan p=new PingPongMan();
        p.run();

        //接口的静态方法,必须接口自己调用
        SportManInter.inAddr();


    }
}

 

package com.ITheima._interface1;

public class Test1 {
    public static void main(String[] args) {
        //1 接口不能创建对象(接口是更加彻底的抽象)

        //2 一个类实现多个接口,多个接口中档由同样的静态方法不冲突

        //3 一个类继承了父类,同时又实现了接口,父类中和接口中又同名方法,默认用父类的
        Cat c=new Cat();
        c.eat();
        //4一个类实现了多个接口,多个接口中存在同名的默认方法,不冲突,这个类重写该方法即可
        CC c1=new CC();
        c1.eat();
        //5 一个接口继承了多个接口,是没有问题的,如果多个接口中存在规范冲突则不能继承

    }
}

interface A{
    static void test(){
        System.out.println("A");
    }
}

interface B{
    static void test(){
        System.out.println("B");
    }
}

/**
 * 2 一个类实现多个接口,多个接口中有同样的静态方法不冲突.
 * 原因是接口的静态方法只能由接口本身调用 ,A调用A B调用B  接口的静态方法类C不能调用
 */
class C implements A,B{

}


// 3 一个类继承了父类,同时又实现了接口,父类中和接口中又同名方法,默认用父类的3
interface Food{
    default  void eat(){
        System.out.println("接口中default默认的eat方法");
    }
}

class  Animal{
    public void eat(){
        System.out.println("父类吃动物");
    }
}

/**
 *  一个类继承了父类,同时又实现了接口
 */
class Cat extends Animal implements Food,A{

}

/*
* 4一个类实现了多个接口,多个接口中存在同名的默认方法,不冲突,这个类重写该方法即可
*/
interface AA{
    default void eat(){
        System.out.println("AA");
    }
}
interface BB{
    default void eat(){
        System.out.println("BB");
    }
}

class CC implements  AA,BB{
    //当类实现接口  多个接口中存在同名方法 重写该方法
    @Override
    public  void eat(){
        System.out.println("执行自己的eat");
    }
}

/*
* 5 一个接口继承了多个接口,是没有问题的,如果多个接口中存在规范冲突则不能继承
*
* */
interface  AAA{
    //run方法 有返回值 int类型
    int run();
}
interface  BBB{
    //run方法 没有返回值
    void run();
}

//AAA BBB接口存在冲突  不能同时继承
//interface  CCC extends AAA,BBB{
//
//}