JAVASE面向对象进阶4---语法

最新推荐文章于 2025-05-30 20:16:38 发布

程序员就是阿欣

最新推荐文章于 2025-05-30 20:16:38 发布

阅读量290

点赞数

分类专栏： java 文章标签： java

原文链接：https://www.bilibili.com/video/BV1Cv411372m?p=129

版权

java 专栏收录该内容

18 篇文章

订阅专栏

本文详细介绍了Java SE中的包概念、创建与导包规则，以及权限修饰符的作用。学习如何正确使用final关键字，区分常量与变量，并通过实例展示常量的使用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、JAVASE面向对象进阶 —包

1、什么是包？

包是用来分门别类的管理各种不同类的。类似于文件夹、建包利于程序的管理和维护。

2、建包的语法格式：package公司域名倒写.技术名称。包名建立全部英文小写，且具备意义

package com.itheima.javabean;
public class Student(){
    
}

建包语句必须在第一行，一般IDEA工具会帮助创建

3、导包

相同包下的类可以直接访，不同包下的类必须导包，才可以使用！导包格式：import 包名.类名;

package com.itheima.d1_package;

//导包、
import com.itheima.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 student = new Student();

        Scanner scanner = new Scanner(System.in);

        //3、如果这个类中使用的不同包下的相同的类名，
        // 此时默认只能导入一个类的包，另一个要使用全名访问。现在it2下又建了一个Student包(it下已经有一个了)  导入的话就要包名访问
        com.itheima.d1_package.it2.Student student1 = new com.itheima.d1_package.it2.Student();

    }
}

二、权限修饰符

1、什么是权限修饰符?

权限修饰符：是用来控制一个成员能够被访问的范围。
可以修饰成员变量、方法、构造器、内部类、不同权限修饰符修饰的成员能够被访问的范围将受到限制。

2、权限修饰符的分类和具体作用范围：

权限修饰符:有四种作用范围由小到大( private --> 缺省–> protected --> public )

修饰符	同一个类中	同一个包中其他类	不同包下的子类	不同包下的无关类
private	√
缺省	√	√
protected	√	√	√
public	√	√	√	√

代码演示：

package com.itheima.d2_modifier;

public class FU {
    /**
     * 定义私有的成员           //只能本类中访问
     */
    private void privateMethod(){
        System.out.println("-----------private-------------");
    }
    /**
     * 定义缺省修饰的成员           //只能本类、同包下其他类访问       （包访问权限）
     */
     void Method(){
        System.out.println("-----------缺省-------------");
    }

    /**
     * protected修饰方法           本类  同包的其他类 其他包的子类中都可以访问
     */
    protected void protectedMethod(){
        System.out.println("-----------protected-------------");
    }
    /**
     * 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();                   //本类中都可以访问

    }

}



package com.itheima.d2_modifier;

public class Test {   //同包的其他类
    public static void main(String[] args) {
        //目标：讲解权限修饰符的修饰范围。明白每一种修饰符后的作用范围。
        FU f = new FU();
        f.Method();
        f.protectedMethod();
        f.publicMethod();
        // f.privateMethod()   报错：同类的其他包下不支持private



    }

}





import com.itheima.d2_modifier.FU;

public class Test2 {   //其他包的无关类
    public static void main(String[] args) {
        FU f = new FU();
        // f.privateMethod();  报错
        // f.Method();   报错
        // f.protectedMethod();  报错
        f.publicMethod();

    }
}




package com.itheima.d2_modifier.itcast;

import com.itheima.d2_modifier.FU;

public class Zi extends FU { //不同包下的子类
    public static void main(String[] args) {
       Zi zi = new Zi();   //要注意的是   不同包下的子类要创建子类对象且拿子类对象访问
       zi.protectedMethod();
       zi.publicMethod();

    }
}

3、学完权限修饰符需要具备如下能力

能够识别别人定义的成员的访问范围。
自己定义成员(方法,成员变量，构造器等) 一般需要满足如下要求：
成员变量一般私有。
方法-一般公开。
如果该成员只希望本类访问，使用private修饰。
如果该成员只希望本类,同-一个包下的其他类和子类访问，使用protected修饰。

三、final关键字

1、final的作用

final 关键字是最终的意思，可以修饰(类、方法、变量)
修饰类：表明该类是最终类,不能被继承。
修饰方法：表明该方法是最终方法，不能被重写。
修饰变量：表示该变量第-次赋值后,不能再次被赋值(有且仅能被赋值一次)。

public class Test {
    public static void main(String[] args) {
        //目标：记住final的语法、
        //1、final修饰类 类不能被继承
        //2、final修饰方法  方法不能被重写


    }
}



  //2、final修饰方法  方法不能被重写
//class Student extends People{
//    @Override
//    public void eat() {
//        System.out.println("学生吃的很多");
//    }
//}
class People{
    public final void eat(){   //final修饰方法  方法不能被重写
        System.out.println("人吃东西");
    }
}



//1、final修饰类 类不能被继承
//class Wolf extends Animal{
//
//}
//final class Animal{
//
//}




public class Test2 {
    /**
     * 二、修饰静态成员变量(常量)
     */

    public static final String schoolName = "青青草原";  // 加上final  在其他地方就不能够再进行修改了

    /**
     *
     * 三、修饰实例成员变量（几乎不用）
     */
    private final static String name = " 猪刚鬣";

    public static void main(String[] args) {
        //目标：3、理解final修饰变量 ，  总规则：变量有且仅能赋值一次(理解语法)
        //变量有两种：1、局部变量  2、成员变量
        //成员变量又分：  1、实例成员变量 2、静态成员变量


        // 二、 schoolName = "懒洋洋";  //不可以进行第二次赋值
        //三、name = "猪八戒";   //不可以进行第二次赋值



        /**
         * 一、修饰局部变量
         */
        final double rate = 3.14;
//        rate = 3.19;    这相当于第二次赋值
    }
    public static void buy(final double z){
      //  z = 0.1;  //这相当于第二次赋值
    }
}

2、final修饰变量的注意：

final修饰的变量是基本类型:那么变量存储的数据值不能发生改变。
final修饰的变量是引用类型:那么变量存储的地址值不能发生改变,但是地址指向的对象内容是可以发生变化的。

四、常量

1、常量

常量是使用了public static final修饰的成员变量,必须有初始化值,而且执行的过程中其值不能被改变。
常量的作用和好处:可以用于做系统的配置信息，方便程序的维护，同时也能提高可读性。

public class Constant{
    public static final String	 SCHOOL_Name = "青青草原";
     public static final String  LOGIN_Name = "admin";
     public static final String   PASS_Word = "123456";
}
//常量命名规范：英文单词全部大写  多个单词下划线连接起来。


public class ConstantDemo1 {
    /**
     *
     * 目标：学会常量的使用并理解常量
     */
    public static final String SCHOOL_NAME = "狼堡集团";
    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);
    }
}