• 【java进阶03： package和import】及访问控制权限

    目录

    package、import

    访问控制权限

    package、import

    1. java语言中的package和import机制：

      1. 1、为什么要使用package？
      2.     package是java中包机制。包机制的作用是为了方便程序的管理。不同功能的类分别放在不同的包下。
      3.     （按照功能划分的，不同的包具有不同的功能）
      4. 2、package怎么用？
      5.     package是一个关键字，后面加包名。例如：
      6.     package com.javase.day1206;
      7.     注意：package语句只允许出现在java源代码的第一行
      8.  
      9. 3、包名有没有命名规范？ 有
      10.     一般采用公司域名倒序的方式（因为公司域名具有全球唯一性。）
      11.     包名命名规范：
      12.     公司域名倒序 + 项目名 + 模块名 + 功能名
      13.  
      14. 4、对于带有package的java程序怎么编译？怎么运行？
      15.     采用之前的编译和运行 不行了
      16.     类名不再是HelloWorld了
      17.     类名：com.javase.day1206.HelloWorld
      18.  
      19.     用文本编辑器编写的带包文件的编译运行：
      20.     在编写当前文件的地址栏cmd直接进入dos界面，然后编译，然后输入以下命令运行
      21.     不能用之前那种切换目录的方式。使用这种方式直接生成包的目录，直接编译不生成目录且无法运行。
      22.     运行时也要在编写java文件的文件夹cmd然后运行，不能切换到class文件所在位置运行。
      23.  
      24.     编译：
      25.     javac -d . HelloWorld.java
      26.     javac 负责编译的命令
      27.     -d    带包编译
      28.     .     代表编译之后生成的东西放到当前目录下(.代表当前目录)
      29.     HelloWorld.java 被编译的java文件
      30.     运行：
      31.     java 完整类名 —— java com.javase.day1206.HelloWorld
      32.  
      33.     注意：
      34.     带包名描述的类名(完整类名)  ：  java.util.Scanner
      35.     不带包名描述的(简类名)      ：  Scanner
      36.  
      37.     用idea时右键src新建包：com.javase.day1206
      38.     生成包之后右键new class，然后取名，然后运行即可。
      39.  
      40. 5、关于import的使用：  两个类不在同一个包中的时候,其中一个类使用了另一个类,此时需要使用import(导包)
      41.     import什么时候使用？
      42.     A类中使用B类
      43.     A类和B类都在同一个包下，不需要使用import
      44.     A类和B类不在同一个包下，需要使用import
      45.     注意：
      46.     java.lang包下的类都不需要导包(但是这个包的子包需要导)。相当于：java.lang.*;在每个类中默认有。
      47.  
      48.     import怎么用？
      49.     import语句只能出现在package语句之下，class声明语句之上
      50.     import语句还可以采用*的方式.
      51.     例:
      52.     import com.javase.day1206.HelloWorld;可以使用:
      53.     import com.javase.day1206.*;
      54.  
      55.     疑问：  import com.javase.day1206.*; 这样是不是效率比较低？
      56.     不是！编译器编译时会把*变为具体的类名。但是要注意：这里的*只代表某些类的名字。
      57.     不要想着用 import Java *; 或import *; 把所有的类导入进来。这样是不现实的。
      1. package com.javase.day1206;
      2.  
      3. public class HelloWorld {
      4.     public static void main(String[] args) {
      5.         System.out.println("HelloWorld");
      6.     }
      7. }

    2. 同一个包中import可以省

      1. package com.javase.day1206;
      2.  
      3. public class Text01 {
      4.     public static void main(String[] args) {
      5.         //创建HelloWorld对象
      6.         com.javase.day1206.HelloWorld hw = new com.javase.day1206.HelloWorld();
      7.         System.out.println(hw);//com.javase.day1206.HelloWorld@1b6d3586
      8.  
      9.         //包名可以省略吗？
      10.         //思考：这里的包名之所以可以省略，是因为这两个类在同一个包中。
      11.         HelloWorld hw2 = new HelloWorld();
      12.         System.out.println(hw2);//com.javase.day1206.HelloWorld@4554617c
      13.     }
      14. }

    3. 不同包的两个类，一个类中要使用另一个类中的东西，必须有import

      1. package com;
      2.  
      3. //import com.javase.day1206.HelloWorld;
      4. //import还可以采用*的方式
      5. import com.javase.day1206.*;
      6.  
      7. public class Text02 {
      8.     public static void main(String[] args) {
      9.         /*
      10.             HelloWorld hw = new HelloWorld();
      11.             System.out.println(hw);
      12.             没有导包之前，编译报错：
      13.                         Error:(6, 9) java: 找不到符号
      14.                           符号:   类 HelloWorld
      15.                           位置: 类 com.Text02
      16.             原因：Text02在com包下，HelloWorld在com.javase.day1206包下
      17.                  不在同一个paceage下，包名不可以省略。
      18.          */
      19.  
      20.         /*想要编译通过，必须这样：
      21.             com.javase.day1206.HelloWorld hw = new com.javase.day1206.HelloWorld();
      22.             System.out.println(hw);
      23.             com.javase.day1206.HelloWorld hw2 = new com.javase.day1206.HelloWorld();
      24.             System.out.println(hw2);
      25.             com.javase.day1206.HelloWorld hw3 = new com.javase.day1206.HelloWorld();
      26.             System.out.println(hw3);
      27.             com.javase.day1206.HelloWorld@1b6d3586
      28.             com.javase.day1206.HelloWorld@4554617c
      29.             com.javase.day1206.HelloWorld@74a14482
      30.          */
      31.  
      32.         //虽然上面那样可以运行，但是每次这样写太麻烦了，所以这里就需要用到import 将需要用到的类导入进来。
      33.         //import com.javase.day1206.HelloWorld;
      34.         //包名.类名   就是带包的类的新名字。
      35.  
      36.         HelloWorld hw1 = new HelloWorld();
      37.         System.out.println(hw1);
      38.     }
      39. }

    4. 解释之前接收键盘输入时使用的java.util.Scanner ，以及使用java.lang.下所有的类都不需要导

      1. package com.javase.day1206;
      2.  
      3. //第二种方法：使用import导包
      4.     //import java.util.Scanner;
      5. //也可以使用*的方式导包
      6. import java.util.*;
      7.  
      8. public class Text03 {
      9.     public static void main(String[] args) {
      10.         //为什么要这样写?
      11.         //因为Text03与Scanner这两个类不在同一个包中,在Text03中使用Scanner类中的东西
      12.         //第一种方法：需要在前面加Scanner类的包名:java.util
      13.         //java.util.Scanner s = new java.util.Scanner(System.in);
      14.  
      15.         //导包之后使用时，类名前就不用加包名了。
      16.         Scanner s = new Scanner(System.in);
      17.         String str = s.next();
      18.         System.out.println("您输入的字符串为:"+str);
      19.  
      20.         //String类为什么不需要导包就可以使用？
      21.         //因为String类在java.lang包下，这个包下的所有类都不需要导包就可以使用！
      22.         java.lang.String name = "张三";
      23.         System.out.println("名字是："+name);
      24.         java.lang.String userName = "李四";
      25.         System.out.println("用户名是："+userName);
      26.     }
      27. }
      28.

    访问控制权限

    访问控制权限有几个，控制范围以及修饰什么？

    1.     1、访问控制权限有4个：
    2.         public     公开的
    3.         private    私有的
    4.  
    5.         protected  受保护的
    6.         什么都不加  默认的
    7.  
    8.     2、访问控制权限各自的控制范围：
    9.         public : 表示公开的，任何位置都可以访问
    10.         private: 表示私有的，只能在本类中访问
    11.  
    12.         “默认”    : 只能在本类、同包 访问
    13.         protected : 本类、同包、子类中访问
    14.  
    15.         访问控制权限        本类         同包         子类        任意位置
    16.         --------------------------------------------------------------------------
    17.           public           可以         可以         可以          可以
    18.           protected        可以         可以         可以           X
    19.           默认              可以         可以          X            X
    20.           private          可以          X            X            X
    21.  
    22.           默认范围从大到小排序：public > protected > 默认 > private
    23.  
    24.       3、访问控制权限符可以修饰什么？
    25.         属性、方法 。 (四个都可以修饰)
    26.         类、接口 。 (public 和 默认。其他的不能修饰)

    本类的 访问控制权限符可以修饰什么东西

    1. package com;
    2.  
    3. public class User{
    4.     //私有的
    5.     private int id;
    6.     //受保护的
    7.     protected int age;
    8.     //公开的
    9.     public int weight;
    10.     //什么都不加：默认的
    11.     String name;
    12.  
    13.     //本类
    14.     public static void main(String[] args) {
    15.         User u = new User();
    16.         System.out.println(u.id);
    17.         System.out.println(u.age);
    18.         System.out.println(u.weight);
    19.         System.out.println(u.name);
    20.     }
    21.  
    22.     //方法
    23.     public void m1(){}
    24.     private void m2(){}
    25.     protected void m3(){}
    26.     void m4(){}
    27.  
    28.     //静态的也可以，访问控制权限与是否静态无关
    29.     public static void a(){}
    30.     private static void b(){}
    31.     protected static void c(){}
    32.     static void d(){}
    33. }
    34.  
    35. //Error: 此处不允许使用修饰符private
    36. //private class MyClass1{}
    37.  
    38. //Error: 此处不允许使用修饰符protected
    39. //protected class MyClass2{}
    40.

    同包的

    1. //同包
    2. package com;
    3.  
    4. public class Text1 {
    5.     public static void main(String[] args) {
    6.         User u = new User();
    7.         
    8.         //Error: id 在 User 中是 private 访问控制
    9.         //System.out.println(u.id);
    10.         
    11.         System.out.println(u.age);
    12.         System.out.println(u.weight);
    13.         System.out.println(u.name);
    14.     }
    15. }

    不同包中

    1. //不同包中
    2. package com.javase;
    3.  
    4. import com.User;
    5.  
    6. public class Text2 {
    7.     public static void main(String[] args) {
    8.         User u = new User();
    9.  
    10.         //Error: age 在 com.User 中是 protected 访问控制
    11.         //System.out.println(u.age);
    12.  
    13.         //公开的，在哪里都可以使用
    14.         System.out.println(u.weight);
    15.  
    16.         //Error: name在com.User中不是公共的; 无法从外部程序包中对其进行访问
    17.         //System.out.println(u.name);
    18.     }
    19. }

    子类中

    1. //不同包，子类
    2. package com.javase.day1206;
    3.  
    4. import com.User;
    5.  
    6. //User在com包下，Vip在com.javase.day1206包下，两个类不在同一个包下。
    7. //但是Vip是User的子类。
    8.  
    9. public class Vip extends User{
    10.     public static void main(String[] args) {
    11.  
    12.     }
    13.     //实例方法
    14.     public void shopping(){
    15.         //this表示当前对象
    16.         //编译通过
    17.         System.out.println(this.age);
    18.  
    19.         //Error: name在com.User中不是公共的; 无法从外部程序包中对其进行访问
    20.         //System.out.println(this.name);
    21.     }
    22. }
  • 相关阅读:
    Ubuntu上安装Chrome浏览器
    天天被开发怼？4个方法区分bug前后端归属，我再也不背锅了！
    区块链技术的应用场景和优势
    数据库总结
    基于Spring Boot的考研资讯平台设计与实现
    内核宕机自救
    IEEE1588v2解析（5）--PTP的传输方式
    使用 Spring Data MongoDB 连接到多个数据库
    中通IM测试实践
    产品经理如何有效跟进开发进度？
  • 原文地址：https://blog.csdn.net/m0_69066786/article/details/127963484