04java基础课堂笔记 - 面向对象课时5 - 包机制与访问控制

158、包机制 package、import

1、package是java的包机制，作用是为了方便程序的管理，将不同功能的类存放在不同的包下，按照功能划分，不同的软件包具有不同的功能
2、package
2.1、声明包：
　　　　package 包名1.包名2.包名3...
　　- package语句编写在java源文件第一行
　　- 一个包代表一个目录,包名之间使用 . 号间隔
2.2、包名的命名规范：
　　　　域名倒序 + 项目名 + 模块名 + 功能名
　　- 一般使用公司域名倒序的方式，因为公司域名具有全球唯一性
　　- 包名也是标识符要求全部小写

3、使用了package包机制之后，如何编译？如何运行呢？
3.1、使用了package机制，类名不再是简单的字节码文件名Test，而是一个带包名的完整类名：包名1.包名2.包名3.类名
　　如Test.class的完整类名是：com.bjpowernode.javase.project10.Test
3.1、如何编译?
1）、当源文件在控制台当前目录下时，源文件路径可以省略，字节码文件的默认保存位置与源文件相同
　　　　　　javac xxx.java
2）、当源文件不在控制台当前目录下时，须指明源文件路径，字节码文件的默认保存位置与源文件相同
　　　　　　javac [源文件路径]\xxx.java

　　- 以上两种，字节码文件默认保存在与源文件相同的位置，因此须手动创建包名目录，并将字节码文件放入该目录，这样才能进行运行

3）、带包编译并指定类文件的保存位置：
　　　　　　javac -d [路径] xxx.java
　　　　　　javac -d . xxx.java
　　- -d 表示带包编译，并且指定生成的 “包目录和.class字节码文件”（即完整类）的保存位置
　　- 即将java源文件带包编译，“包和字节码文件” 保存到指定路径下
　　- . 表示控制台当前目录，-d后面的路径不能为空
　　- “-d [路径]” 省缺时，同3.1.1，字节码文件默认保存在与源文件相同的位置

　　　　　　javac -d . *.java
　　- * 表示所有 .java源文件
　　- 即编译所有.java源文件，并保存到控制台当前目录下

4）、删除当前目录下所有.class字节码文件
　　　　　　del *.class

3.2、如何运行？
1）、JVM的类加载器ClassLoader默认从控制台当前目录下加载类，所以要确保控制台当前目录与字节码文件或包所在的目录相同
2）、未使用包机制时，xxx.class字节码文件的保存位置默认与源文件相同，可以采用缺省类名方式运行字节码文件
　　　　　　java xxx

3）、当使用了包机制时，xxx.class字节码文件保存在包名目录里，须采用完整类名方式运行
　　　　　　java 包名1.包名2.包名3.xxx
　　　　- 如果使用省缺方式编译，字节码文件默认保存位置与源文件相同，因此须手动创建包名目录，并将字节码文件放入该目录再运行

4、import

4.1、为了省略包名，方便编程，使用import机制
　　当引用类与当前类不在同一个包下时，由于编译器默认会在当前包下去找字节码文件，因此须采用完整类名的方式编写引用类，包名不能省略
　　为了方便编程，使用import机制，导入其它包下的类，从而实现省略包名，采用简化类名的方式的去引用类

4.2、import什么时候使用？
1）、java.lang.包下的类不需要手动导入，系统支持自动引入
　　常用类如：String、System、Math
2）、引用的类与当前类，是同包下的类不需要导入
3）、引用的类是其它包的类，不同包的类需要导入，否则无法省略包名
4.3、怎么用？
1）、import语句必须编写在package语句之下，class语句之上
2）、使用完整类名导入
　　　　　　import 包名1.包名2.包名3.xxxx ;
3）、导入所有类
　　　　　　import 包名1.包名2.包名3.* ;
　　- * 代表所有类，效率不会降低，因为编译器在编译的时候，会自动把 * 变成具体的类名支持多行
　　如：import java.util.Scanner;
　　　　import java.util.*;

示例1：声明包

复制代码
package com.bjpowernode.javase.project10;

public class Test{
    public static void main(String[] args){
        System.out.println("Test's main method execute");
    }
}
View Code
复制代码

示例2：当引用类Test与当前类Test2不在同一个包下时，须使用完整类名，import机制

复制代码
package com.bjpowernode.javase.project11;

import com.bjpowernode.javase.project10.Test;

public class Test2{
    public static void main(String[] args){
        /*
        以下代码编译错误，当省略包名之后，编译器会在当前包下找Test
        实际上编译器去找com.bjpowernode.javase.project11.Test这个类了，但这个类不存在
        */
        //Test t = new Test();
        
        //使用import机制导入Test类之后，就可以采用简洁类名方式编写了
        Test t = new Test();

        
        //Test和当前类Test2不在同一个软件包下，包名不能省略
        com.bjpowernode.javase.project10.Test tt = new com.bjpowernode.javase.project10.Test();
        
        System.out.println(t);
        System.out.println(tt);
    }
}
View Code
复制代码

 

 

159、访问控制权限修饰符：
1.1、访问控制权限修饰符用来控制元素的访问范围
　　权限排序为：public > protected > 默认 > private
1.2、访问控制权限修饰符有哪些？
　　private   私有的   只能在本类中访问
　　default   缺省的/默认   只能在本类和同包下访问，非同包下的子类也不能继承（不能显性使用“default”修饰）
　　protected 受保护的   同上只能在本类和同包下访问，但非同包下的子类可以继承，使用this.访问
　　public     公开的   可以在任何位置访问

访问控制修饰符　　本类　　同包　　子类　　任意位置
----------------------------------------------------------------------------
public　　　　　　 可以　　可以　　可以　　可以
protected　　　　  可以　　可以　　可以　　no
default　　　　　　可以　　可以　　no　　　no
private　　　　　　可以　　no　　　no　　　no

1.3、访问控制权限修饰符可以修饰什么？
属性，4个修饰都能用
方法，4个修饰都能用
类，　只能用 public 和缺省修饰
接口，只能用 public 和缺省修饰

示例1：private、缺省修饰 本类及同包下的访问权限

复制代码
package com.bjpowernode.javase.project10;

public class Test{
    public static void main(String[] args){
        
        //实例化同包类，省略包名
        //protected与省缺修饰的元素，都可以在本类或同包的类中访问
        //protected修饰的元素，还可以在它的子类中访问
        User u = new User();
        
        //System.out.println(u.i1);  //private 访问控制
        System.out.println(u.i2);  //缺省的 同包下可以访问
        System.out.println(u.i3);
        System.out.println(u.i4);
        
        //u.m1();  //private 访问控制
        u.m2();  //缺省的 同包下可以访问
    }
}

class User{
    private int i1 = 10;
    int i2 = 20;
    protected int i3 = 30;
    public int i4 = 40;
    
    private void m1(){
        System.out.println("m1 method execute!!! " + this.i1);
    }
    void m2(){
        System.out.println("m2 method execute!!!");
        this.m1();
    }
    protected void m3(){}
    public void m4(){}
}
View Code
复制代码

示例2：protacted修饰 非同包的子类的访问权限
编译：javac -d . *.java
运行：java com.bjpowernode.javase.project10.Test

主类Test 10包 

复制代码
package com.bjpowernode.javase.project10;

public class Test{
    public static void main(String[] args){

        //实例化同包类，省略包名
        //protected与省缺修饰的元素，都可以在本类或同包的类中访问
        //protected修饰的元素，还可以在它的子类中访问
        User u = new User();
        
        //System.out.println(u.i1);  //private 访问控制 只能在本类中访问
        System.out.println(u.i2);  //20 default
        System.out.println(u.i3);  //30 protected
        System.out.println(u.i4);  //40 public
        
        //u.m1();  //private 访问控制 只能在本类中访问
        u.m2();  //m2 method execute!!!
        u.m3();  //m3 method execute!!!
        u.m4();  //m4 method execute!!!
        
        com.bjpowernode.javase.project11.Vip v = new com.bjpowernode.javase.project11.Vip();
        v.m();
        
        com.bjpowernode.javase.project12.Vip2 v2 = new com.bjpowernode.javase.project12.Vip2();
        v2.m();
    }
}
View Code
复制代码

User类 10包

复制代码
package com.bjpowernode.javase.project10;

public class User{
    private int i1 = 10;
    int i2 = 20;
    protected int i3 = 30;
    public int i4 = 40;
    
    private void m1(){
        System.out.println("m1 method execute!!! " + this.i1);
    }
    void m2(){
        System.out.println("m2 method execute!!!");
        this.m1();
    }
    protected void m3(){
        System.out.println("m3 method execute!!!");
    }
    public void m4(){
        System.out.println("m4 method execute!!!");
    }
}
View Code
复制代码

Vip类 11包 Vip继承User

复制代码
package com.bjpowernode.javase.project11;

import com.bjpowernode.javase.project10.User;

public class Vip extends User{
    public void m(){
        User u = new User();
        //private 访问控制
        //System.out.println(u.i1);  
        
        //default，非同包下不能访问，非同包下也不能被继承
        //System.out.println(u.i2);  
        //System.out.println(this.i2);  
        
        //protected 访问控制，非同包下不能访问，但非同包下的子类可以继承
        //System.out.println(u.i3);  
        System.out.println(this.i3);  //30
        
        //public
        System.out.println(u.i4);  //40
        
        //u.m1();  //private 访问控制
        //u.m2();  //default，非同包下不能访问，非同包下也不能被继承
        //this.m2();
        //u.m3();  //protected 访问控制，非同包下不能访问，但非同包下的子类可以继承
        this.m3();  //m3 method execute!!! 
        u.m4();  //m4 method execute!!!
    }
}
View Code
复制代码

Vip2类 12包 无继承

复制代码
package com.bjpowernode.javase.project12;

import com.bjpowernode.javase.project10.User;

public class Vip2{
    public void m(){
        User u = new User();
        //System.out.println(u.i1);  //private 访问控制
        //System.out.println(u.i2);  //default 非同包下不能访问
        //System.out.println(u.i3);  //protected 访问控制，非同包下不能访问
        System.out.println(u.i4);  //40 public
        
        //u.m1();  //private 访问控制
        //u.m2();  //default 非同包下不能访问
        //u.m3();  //protected 访问控制，非同包下不能访问
        u.m4();  //m4 method execute!!!
    }
}
View Code
复制代码

 

 

 

 

 

//即使再小的帆也能远航20220307

posted @   冬雪雪冬小大寒  阅读(56)  评论(0)  编辑  收藏  举报
相关博文：
·  05java课堂笔记 - Object类的方法、匿名内部类
·  java基础课堂笔记04 - 面向对象作业题
·  Java-访问控制
·  第十七章 package、import以及访问控制权限
·  JavaSE--包package和import以及访问控制权限
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 三行代码完成国际化适配，妙~啊~
· .NET Core 中如何实现缓存的预热？
点击右上角即可分享
微信分享提示
SQL AI 助手