Java 包，权限修饰符，final，常量，枚举，抽象类，接口

程序员希西子

已于 2023-09-16 16:46:51 修改

阅读量110

点赞数

分类专栏： Java面向对象进阶栏文章标签： java jvm 开发语言

于 2023-03-18 23:01:20 首次发布

本文链接：https://blog.csdn.net/wangjh11234/article/details/129632445

版权

Java面向对象进阶栏专栏收录该内容

17 篇文章 0 订阅

订阅专栏

一.包

package com.wjh.d1_package;

//自动导包

import com.wjh.d1_package.it.Student;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //目标：理解以下两点
        //1.同一个包下的类，可以互相直接访问
        System.out.println(User.onlineNumber);
        //2.不同包下的类，必须先导包才可以进行访问
        Student s = new Student();
        Scanner sc = new Scanner(System.in);

        //3.假如一个类中需要用到不同类，而这个两个类的名称是一样的，那么默认只能导入一个类，另一个类要带包名访问。
        com.wjh.d1_package.it2.Student s1 = new com.wjh.d1_package.it2.Student();

    }

}

二.权限修饰符

package com.wjh.d2_modifier;

public class fu {
    /*
    1.定义私有的成员:private只能在本类中访问
     */
    private void privateMethod(){
        System.out.println("==========private=========");
    }

    /*
    2.定义缺省修饰的成员：private只能在本类中访问(包访问权限)
     */
    void method(){
        System.out.println("=====private=====");
    }

    /*
    3.protected修饰的方法：本类，同包的其它类中，其他包的子类中。
     */
    protected void protectedMethod(){
        System.out.println("=====protected=====");
    }

    /*
    4.public修饰的方法：本类，同包的其它类中，其他包的子类中,其它包的无关类中
     */
    public void publicMethod(){
        System.out.println("=====public=====");
    }

    public static void main(String[] args) {
        fu f = new fu();
        f.privateMethod();
        f.method();
        f.protectedMethod();
        f.publicMethod();
    }


}

三.final

package com.wjh.d3_final;

public class Test2 {
    /**
     * 二：修饰静态成员变量（ public static final 修饰的也称为常量了）
     */
    public static final String schoolName = "王王";

    /**
     *三：修饰实例成员变量。（几乎不用）
     */
    private final String name = "西子";


    public static void main(String[] args) {
        //3.final修饰变量，总规则：变量有且仅能赋值一次（理解语法）
        /*
        变量有几种：
        1.局部变量
        2.成员变量
            （1）实例成员变量
            （2）静态成员变量
         */
        final double rate = 3.14;   //final保护
        //rate = 3.19;  //报错：只能赋值一次

        buy(0.8);

        //schoolName = "希希";    //报错：只能赋值一次

        Test2 t = new Test2();
        System.out.println(t.name);
        //t.name = "描娘";    //报错：只能赋值一次
    }

    public static void buy(final double z){
        //z = 0.1;      //报错：只能赋值一次

    }
}
package com.wjh.d3_final;

public class Test2 {
    /**
     * 二：修饰静态成员变量（ public static final 修饰的也称为常量了）
     */
    public static final String schoolName = "王王";

    /**
     *三：修饰实例成员变量。（几乎不用）
     */
    private final String name = "西子";


    public static void main(String[] args) {
        //3.final修饰变量，总规则：变量有且仅能赋值一次（理解语法）
        /*
        变量有几种：
        1.局部变量
        2.成员变量
            （1）实例成员变量
            （2）静态成员变量
         */
        final double rate = 3.14;   //final保护
        //rate = 3.19;  //报错：只能赋值一次

        buy(0.8);

        //schoolName = "希希";    //报错：只能赋值一次

        Test2 t = new Test2();
        System.out.println(t.name);
        //t.name = "描娘";    //报错：只能赋值一次
    }

    public static void buy(final double z){
        //z = 0.1;      //报错：只能赋值一次

    }
}

package com.wjh.d3_final;

public class Test {
    public static void main(String[] args) {
        //目标：记住final的语法
        //1.final修饰类，类不能继承
        //2.final修饰方法，方法不能被重写
        //3.final修饰变量，总规则：变量有且仅能赋值一次
    }
}

        //class Student extends People{
        //    @Override
        //    public void eat() {
        //        System.out.println("学生吃的很多");
        //    }
        //}

class People{
    public final void eat(){
        System.out.println("人要吃东西！~~~");
    }
}




        //class Wolf extends Anial{     //报错：final修饰的类已经绝育了，不能被继承
        //
        //}

        //final class Anial{
        //
        //}

package com.wjh.d3_final;

public class Test2 {
    /**
     * 二：修饰静态成员变量（ public static final 修饰的也称为常量了）
     */
    public static final String schoolName = "王王";

    /**
     *三：修饰实例成员变量。（几乎不用）
     */
    private final String name = "西子";


    public static void main(String[] args) {
        //3.final修饰变量，总规则：变量有且仅能赋值一次（理解语法）
        /*
        变量有几种：
        1.局部变量
        2.成员变量
            （1）实例成员变量
            （2）静态成员变量
         */
        final double rate = 3.14;   //final保护
        //rate = 3.19;  //报错：只能赋值一次

        buy(0.8);

        //schoolName = "希希";    //报错：只能赋值一次

        Test2 t = new Test2();
        System.out.println(t.name);
        //t.name = "描娘";    //报错：只能赋值一次

        //注意：final修饰引用类型的变量，其他地址值不能被改变的。
        final Teacher t2 = new Teacher("学习，授课");
        //t2 = null;    //报错：只能赋值一次
        System.out.println(t2.getHobby());
        t2.setHobby("运动");
        System.out.println(t2.getHobby());
    }

    public static void buy(final double z){
        //z = 0.1;      //报错：只能赋值一次

    }
}

    class Teacher{
        private String hobby;

        public Teacher(String hobby) {
            this.hobby = hobby;
        }

        public String getHobby() {
            return hobby;
        }

        public void setHobby(String hobby) {
            this.hobby = hobby;
        }
    }

四.常量

package com.wjh.d4_constant;
/*
    学会常量的使用，并理解常量
 */
public class ConstantDemo {

    public static final String SCHOOL_NAME = "江西省教育集团";
    public static final String USER_NAME = "admin";
    public static final String PASS_WORD = "123456";

    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);
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);

        if(USER_NAME.equals("")){

        }

    }
}

江西省教育集团
江西省教育集团
江西省教育集团
江西省教育集团
江西省教育集团
江西省教育集团
江西省教育集团

进程已结束，退出代码为 0

五.枚举

/*
    反编译
*/
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 {};
}

枚举的作用：

package com.wjh.d5_enum;
/*
    枚举类
 */

public enum Season {
    //枚举的第一行必须罗列枚举类的对象名称.建议大写
    SPRING,SUMMER,AUTUMN,WINTER

}

六.抽象类

1.抽象类

package com.wjh.d6_abstrast;

    //抽象类有abstract修饰
public abstract class Animal {
    //抽象方法abstract修饰，不能写{ }方法体
    public abstract void run();
}

package com.wjh.d6_abstrast;

public  class Dog extends Animal{

    private String name;

    public void run(){
        System.out.println("我跑得快");
    }
}

package com.wjh.d6_abstrast;

public class Test {
    public static void main(String[] args) {
        //目标：认识抽象类，再了解他的使用场景
        Dog d = new Dog();
        d.run();

    }
}

我跑得快

进程已结束，退出代码为 0

2.抽象类的应用案例

package com.wjh.d6_carDemo;

public abstract class Card {
    private String useName;
    private double price;   //卡片余额


    /**
     * 定义一个支付方法：表示可以支付
     * 抽象方法
     */
    public abstract void pay(double price1); //消费金额

    public Card() {
    }

    public Card(String useName, double price) {
        this.useName = useName;
        this.price = price;
    }

    public String getUseName() {
        return useName;
    }

    public void setUseName(String useName) {
        this.useName = useName;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

package com.wjh.d6_carDemo;

public class GoldCard extends Card{

    @Override   //方法重写
    public void pay(double price1) {
        System.out.println("您当前消费：" + price1);
        System.out.println("您卡片当前余额是：" + getPrice() );
        //进行优惠价计算：
        double rs = price1 * 0.8;
        System.out.println(getUseName() + "您实际需要支付的金额是：" + rs);
        //更新账户余额:
        setPrice(getPrice() - rs);

    }
}

package com.wjh.d6_carDemo;

public class Test {
    public static void main(String[] args) {
        //目标：学习一下抽象类的基本使用：做父类，被继承，重写的方法
        GoldCard g = new GoldCard();
        g.setPrice(10000);
        g.setUseName("塞班");

        g.pay(300); //消费300
        System.out.println("剩余：" + g.getPrice());


    }
}

您当前消费：300.0
您卡片当前余额是：10000.0
塞班您实际需要支付的金额是：240.0
剩余：9760.0

进程已结束，退出代码为 0

3.抽象类的特征、注意事项

package com.wjh.d7_abstast;

public class Test {
    public static void main(String[] args) {
        //目标：理解抽象类的特征和注意事项
        /*
        1.类有的成员（成员变量、方法、构造器）抽象类都具备
        2.抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
        3.一个类继承了抽象类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
        4.不能用abstract修饰变量、代码块、构造器。
        5. >>> 最重要的特征：得到了抽象方法，失去了创建对象的能力（有得有失）
           为什么？？？<<<
           反证法：假如抽象类可以创建对象
           Animal a = new Animal();
           a.run();     //run方法连方法体都没有，抽象类本身就不能让方法有方法体，因此抽象类不能创建对象

         */
        
        // Animal a = new Animal();

        //Card c =  new Card(); //报错，抽象方法不能创建对象（这个观点不能动摇）
    }
}

abstract class Card{
    private String name;
}



/*
3.一个类继承了抽象类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
 */
abstract class Cat extends Animal{

    @Override
    public void run() {

    }

    @Override
    public void eat() {

    }
}

/*
2.抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
 */
abstract class Animal{
    public abstract void run();
    public abstract void eat();
}

4.抽象类的应用知识：模板方法模式

package com.wjh.d8_abstract_tmpplate;

public abstract class Student {
    /*
    正式声明模板方法模式
     */
    public void write(){
        System.out.println("\t\t\t\t《我的儿子》");
        System.out.println("我的儿子是啥样，来说说：");
        /*正文（每个子类都要写正文，但是每一个子类写的情况不一样）
        因此，模板方法把正文部分定义成抽象方法，交给具体的子类来完成
         */
        System.out.println(writeMain());


        System.out.println("儿子");
    }
    public abstract String writeMain();
}

package com.wjh.d8_abstract_tmpplate;

public class StudentChild extends Student{
//        System.out.println("\t\t\t\t《我的儿子》");
//        System.out.println("我的儿子是啥样，来说说：");
//        //正文
//        System.out.println("我的儿子太牛了，总是烤100分");
//        System.out.println("儿子太棒了");
//
//        System.out.println("儿子");

    @Override
    public String writeMain() {
        return "我的儿子太牛了，总是烤100分";
    }

}

package com.wjh.d8_abstract_tmpplate;

public  class StudentMiddle extends Student{
//        System.out.println("\t\t\t\t《我的儿子》");
//        System.out.println("我的儿子是啥样，来说说：");
//        //正文
//        System.out.println("我的儿子考了0分");
//        System.out.println("我的儿子只会烤地瓜");
//
//        System.out.println("儿子");

    @Override
    public String writeMain() {
        return "我的儿子考了0分,我的儿子只会烤地瓜";
    }

}

package com.wjh.d8_abstract_tmpplate;

public class Test {
    public static void main(String[] args) {
        //目标：理解模板方法模式的思想和使用步骤

        StudentMiddle s = new StudentMiddle();
        s.write();

        StudentChild s1 = new StudentChild();
        s1.write();
    }
}

《我的儿子》
我的儿子是啥样，来说说：
我的儿子考了0分,我的儿子只会烤地瓜
儿子
《我的儿子》
我的儿子是啥样，来说说：
我的儿子太牛了，总是烤100分
儿子

进程已结束，退出代码为 0

七.接口

1.接口概述，特点

接口的定义与特点：

接口的格式如下：

//接口用关键字interface来定义
public interface 接口名{
    //常量
    //抽象方法
}

package com.wjh.d9_interface;
/*
    interface 代表声明了一个接口
 */

public interface InterfaceDemo {
    //目标：接口中成分的特点：JDK 8 之前接口中只能有抽象方法和常量
    //1.常量
    public static final String SCHOOL_NAME = "江西省教育厅";

    //2.抽象方法
    public abstract void eat();
    public abstract void run();
    
}

什么是接口：

接口是一种规范

package com.wjh.d9_interface;
/*
    interface 代表声明了一个接口:体现一种规范：规范一定是公开的
    注意：由于接口体现规范思想，规范默认是公开的，所以代码层面，public abstract可以省略不写
 */

public interface InterfaceDemo {
    //目标：接口中成分的特点：JDK 8 之前接口中只能有抽象方法和常量

    //1.常量
    //public static final String SCHOOL_NAME = "江西省教育厅";
    String SCHOOL_NAME = "江西省教育厅";  //与上面一样

    //2.抽象方法
    //注意：由于接口体现规范思想，规范默认是公开的，所以代码层面，public abstract可以省略不写
    //public abstract void eat();     //默认是公开的
    void run();     //与上面一样
    //public abstract void run();

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

}

2.接口基本的使用，被实现

接口的用法：

接口是用来被类实现（implemens）的，实现接口的类称为实现类。实现类可以理解成所谓的子类。

修饰符 class 实现类 implements 接口1，接口2，接口3，...{

}
实现的关键字:implements

从上面可以看出，接口可以被类单实现，也可以被类多实现。

接口

package com.wjh.d10_implements;

/**
 * 规范
 */

public interface sportMan {
    void run();
    void competition(); //比赛


}

package com.wjh.d10_implements;

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

类

package com.wjh.d10_implements;

/**
 * 实现类
 */

public class PingPongMan implements sportMan, Law{
    private  String name;

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


    @Override
    public void run() {
        System.out.println(name + "必须跑步训练！");

    }

    @Override
    public void competition() {
        System.out.println(name + "要参加比赛，为国家争光");
    }

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

Test

package com.wjh.d10_implements;

public class Test {
    public static void main(String[] args) {
        //目标：理解接口的基本使用：被类实现
        PingPongMan p = new PingPongMan("张继科");
        p.run();
        p.competition();
        p.rule();
    }
}

张继科必须跑步训练！
张继科要参加比赛，为国家争光
张继科必须遵纪守法

进程已结束，退出代码为 0

接口实现的注意事项：

一个类实现接口，必须写完全部接口的抽象方法，否则这个类需要定义成抽象类。

3.接口与接口的关系：多继承

基本小结：

类和类的关系：单继承

类和接口的关系：多实现

接口和接口的关系：多继承，一个接口可以同时继承多个接口。

接口多继承的作用：

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

People接口

package com.wjh.d12_interface_extends;

public interface People {
    void eat();
    void sleep();
}

Law接口

package com.wjh.d12_interface_extends;

public interface Law {
    void rule();
}

SportMan接口

package com.wjh.d12_interface_extends;

/**
 * 接口可以多继承：一个接口可以同时继承多个接口
 */
public interface SportMan extends Law, People{
    void run();
    void competition();
}

BasketballMan接口

package com.wjh.d12_interface_extends;

/**
 * 一个实现类的：
 */

    //Alt + Enter键 --> 实现方法
public class BasketballMan implements SportMan{


    @Override
    public void rule() {
        
    }

    @Override
    public void eat() {

    }

    @Override
    public void sleep() {

    }

    @Override
    public void run() {

    }

    @Override
    public void competition() {

    }
}

4.JDK8开始接口新增方法

JDK8版本开始后，Java只对接口的成员方法进行了新增

原因如下：

项目Version2.0需要对inter接口丰富，加入10个新的抽象方法，此时改变了接口就要是有实现类实现这些方法。

第一种：默认方法

1.类似之前写的普通实例方法：必须用dafaul修饰

2.默认会public修饰。需要用接口实现类的对象来调用

第二种：静态方法

1.默认会public修饰，必须static修饰。

2.注意：接口的静态方法必须用本身的接口名来调用。

第三种：私有方法

1.就是私有的实例方法：必须用private修饰，从JDK1.9才开始有的。

2.只能在本类中被其他的默认方法或私有方法访问。

package com.wjh.d13_interface_jdk8;

public interface SportMan {
    /**
     * JDk 8开始：默认方法
     * --必须用default
     * --默认方法：接口不能创建对象，这个方法只能过继给实现类，由实现类的对象调用
     */
     default void run(){  //--必须用default  public可以省略不写
         go();
         System.out.println("跑的很快！");
    }

    /**
     * 第二种：静态方法
     *1.默认会public修饰，必须static修饰。
     *2.注意：接口的静态方法必须用本身的接口名来调用。
     */
    public static void inAddress(){     //必须static修饰
        System.out.println("我们都在学习Java新增方法的语法，他是Java源码自己会调用的！");
    }

    /**
     *  第三种：私有方法（实例方法）
     *1.就是私有的实例方法：必须用private修饰，从JDK1.9才开始有的。
     *2.只能在本类中被其他的默认方法或私有方法访问。
     */
    private void go(){
        System.out.println("开始跑");
    }


}

class PingPongMan implements SportMan{

}

class Test{
    public static void main(String[] args) {
        PingPongMan p = new PingPongMan();
        p.run();        //调用干爹的接口方法
        //p.go();       //报错！

        SportMan.inAddress();

        //PingPongMan.inAddress();  //报错！





    }
}

开始跑
跑的很快！
我们都在学习Java新增方法的语法，他是Java源码自己会调用的！

进程已结束，退出代码为 0

5.使用接口的注意事项

package com.wjh.d14_interface_attention;

import com.Test.demo3_Employee.Maintainer;

public class Test {
    public static void main(String[] args) {
        /**
         * 1.接口不能创建对象(接更加彻底的抽象)
         * 2.一个类实现多个接口，多个接口中有同样的静态方法不冲突。

         * 3.一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。
         * 4.一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可。
         * 5.一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承。
         */

        Cat c = new Cat();
        c.eat();        //默认用父类的。 --父类动物吃！--
    }
}

/**
 * 5.一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承。
 */
interface AAA{
    void run();

}

interface BBB{
    void run();
}

interface CCC extends AAA,BBB{
    
}

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

interface BB{
    default void go(){
        System.out.println("BB");
    }
}

class CC implements AA,BB{

    @Override
    public void go() {

    }
}



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

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

class Cat extends Animal implements Food,A,B{

}



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

interface B{
    public static void test(){
        System.out.println("B");
    }
}
/**
 * 2.一个类实现多个接口，多个接口中有同样的静态方法不冲突。
 */
class C implements A,B{
    public static void main(String[] args) {
        //c.test();     //报错,原因：原因是接口的静态方法不能C调用，只能A调A的，B调B的、

    }
}