Java基础——package+权限修饰符+内部类

简介: Java基础——package+权限修饰符+内部类

package

package就是文件夹,将字节码(.class)进行分类存放 。包的注意事项:

  • 包的写法:package 包名
  • package语句必须是程序的第一条可执行的代码
  • package语句在一个java文件中只能有一个
  • 如果没有package,默认表示无包名
带包的类的编译和运行

编译:在D盘下有Person_Test.java ,在D盘下打开dos命令行执行 javac -d . Person_Test.java 命令就会生成一个D:/com/heima/Person_Test.class

运行:在D盘下打开dos命令行(当前路径下,不要跑到D:/com/heima去打开dos) 执行java com.heima.Person_Test

不同包下类之间的访问

1)类的全路径名 变量名 = new 类的全路径名();

案例:一个java文件里面是Demo1_Package类

   package com.heima;
•      class Demo1_Package {
•          public static void main(String[] args) {
•              //Person p = new Person();          //报错:不同包下的类不能直接访问
•              com.baidu.Person p = new com.baidu.Person();    //类的全路径名
•      }
•   }
•   package com.baidu;
•   class Person {
•      String name;
•      int age;
•   }


2)package和class之间加入一个"import 包;"然后就可以直接访问不同包下的类了

案例:一个java文件里面是Demo2_Package类

•   package com.heima;
•   import com.baidu.Person;            //导包
•   class Demo2_Package {
•      public static void main(String[] args) {
•          Person p = new Person();    //导包后,就能直接访问了
•      }
•   }
•   package com.baidu;
•   class Person {
•      String name;
•      int age;
•   }

修饰符

权限修饰符的访问权限

image.png

  • private: 是为本类准备的
  • 默认:是为同一个包下的类准备的
  • protected:是为子类准备的,无论子类在任何地方
  • public: 为所有类准备的
每个内容一般都用什么修饰符修饰
  • 类:public
  • 成员变量:private
  • 构造方法:public (当定义一个工具类的时候 可以用private)
  • 成员方法:public
  • 接口中的成员变量:public static final
  • 接口中的成员方法:public abstract

内部类

类内部的类就叫做内部类

访问特点
  • 外部类访问内部类里面的内容 ,必须创建内部类的对象来访问
  • 内部类访问外部类的内容, 直接访问包括私有

代码:

•   class Demo1_InnerClass {
•      public static void main(String[] args) {
           //报错,因为内部类是写在其他类的内部 不能这样直接创建内部类的对象
•          //Inner i = new Inner();
•          //i.method();
           //创建内部类对象格式:外部类名.内部类名 = 外部类对象.内部类对象
•          Outer.Inner oi = new Outer().new Inner();  
•          oi.method();
•      }
•   }
•   class Outer {
•      private int num = 10;//外部类的私有属性
•      class Inner {
•          String name = "内部类";
•          public void method() {
•              System.out.println(num);//内部类访问外部类的内容, 直接访问包括私有
•          }
•      }
•      public void show(){
•          //System.out.println(name);//报错:外部类不能直接访问内部类的内容
•          Inner i = new Inner();
           //这样才是正确的,外部类访问内部类里面的内容,必须创建内部类的对象来访问
•          System.out.println(i.name);
•      }
•   }

成员私有内部类

   class Demo2_InnerClass {
•      public static void main(String[] args) {
•          //Outer.Inner oi = new Outer().new Inner();
           //不能创建私有内部类的对象,因为内部类被私有了
•          //oi.method();
•          Outer o = new Outer();
•          o.print();
•      }
•   }
•   class Outer {
•      private int num = 10;
•      private class Inner {              
       //内部类私有是为了让内部的这个类更安全 比如:内部类就相当于人类的心脏
       //怎么能让外面直接访问你的心脏呢?
•          public void method() {
•              System.out.println(num);
•          }
•      }
•      public void print() {
•          Inner i = new Inner();
•          i.method();
•      }
•   }
内部类对象访问当前外部类对象的成员变量
class Test_InnerClass {
•      public static void main(String[] args) {
•          Outer ot = new Outer();
•          ot.num = ot.num - 5;
•          Outer.Inner oi = ot.new Inner();
•          oi.show();
•      }
•   }
•   class Outer {
•      public int num = 10;
•      class Inner {
•          public int num = 20;
•          public void show() {
•              int num = 30;
•              System.out.println(num);//访问的是局部变量 30
•              System.out.println(this.num);//访问的是成员变量 20
               //外部类名.this访问的是当前外部类对象的num 5
               //因为当前外部类对象ot的num值已经改变成了5 ot.num=ot.num-5
•              System.out.println(Outer.this.num);
•              System.out.println(new Outer().num);//一个新的外部类对象的num 10
•          }
•      }
•   }
局部内部类访问局部变量,局部变量前面必须加final修饰,为了延长局部变量的生命周期
class Demo1_InnerClass {
•      public static void main(String[] args) {
•          Outer o = new Outer();
•          o.method();
•      }
•   }
class Outer {
•   public void method() {
•      final int num = 10;
•      class Inner {
•          public void print() {
•              System.out.println(num);
•          }
•      }
•      Inner i = new Inner();//对象的生命周期比局部变量长,
•      i.print();  
•      //当method()方法执行完毕后,i还存在着,就会导致如果i对象还想访问num,而
•      //num已经消失了,访问不到了。所以在num前面加final 永远放到常量池里面去,常量池的
•      //东西永远都不会消失(虚拟机挂掉才会消失)
•   }
}

匿名内部类

前提:有一个接口或者抽象类或者普通的类格式:

new 接口名或者抽象类名(){
   重写方法;
};

本质:就是接口或者抽象类或者普通类的一个子类对象代码:

interface Inter{
   public abstract void show();
}
class Demo {
   public static void main(String[] args){
       new Inter(){
           public void show(){
               System.out.println("hehe");
           }
       }.show();
   }
}
  • 匿名内部类可以重写多个方法, 但是一般开发中就让其重写一个方法。
  • 匿名内部类是不能向下转型的,因为没有子类类名,所以不能使用匿名内部类里面的特有方法。
  • 当我们看到一个方法的参数类型是抽象类或者接口的时候, 我们调用这个方法的时候,可以考虑用匿名内部类来实现。
课后习题:补齐代码,使得控制台输出HelloWorld
   interface Inter {
       void show();
   }
   class Outer {
   //补齐代码
   }
   class OuterDemo {
       public static void main(String[] args) {
           Outer.method().show();
       }
   }

今天学习了package和导包(import)之后是不是觉得编译步骤很复杂啊?下节我们将学习用Eclipse来编译运行程序。想了解更多学习知识,请关注微信公众号“阿Q说”,获取更多学习资料吧!你也可以后台留言说出你的疑惑,阿Q将会在后期的文章中为你解答。每天学习一点点,每天进步一点点。

相关文章
|
1月前
|
存储 缓存 Java
java基础:IO流 理论与代码示例(详解、idea设置统一utf-8编码问题)
这篇文章详细介绍了Java中的IO流,包括字符与字节的概念、编码格式、File类的使用、IO流的分类和原理,以及通过代码示例展示了各种流的应用,如节点流、处理流、缓存流、转换流、对象流和随机访问文件流。同时,还探讨了IDEA中设置项目编码格式的方法,以及如何处理序列化和反序列化问题。
67 1
java基础:IO流 理论与代码示例(详解、idea设置统一utf-8编码问题)
|
2月前
|
安全 Java API
【Java面试题汇总】Java基础篇——String+集合+泛型+IO+异常+反射(2023版)
String常量池、String、StringBuffer、Stringbuilder有什么区别、List与Set的区别、ArrayList和LinkedList的区别、HashMap底层原理、ConcurrentHashMap、HashMap和Hashtable的区别、泛型擦除、ABA问题、IO多路复用、BIO、NIO、O、异常处理机制、反射
【Java面试题汇总】Java基础篇——String+集合+泛型+IO+异常+反射(2023版)
|
2月前
|
Java API 数据处理
Java 包(package)的作用详解
在 Java 中,包(package)用于组织和管理类与接口,具有多项关键作用:1)系统化组织代码,便于理解和维护;2)提供命名空间,避免类名冲突;3)支持访问控制,如 public、protected、默认和 private,增强封装性;4)提升代码可维护性,实现模块化开发;5)简化导入机制,使代码更简洁;6)促进模块化编程,提高代码重用率;7)管理第三方库,避免命名冲突;8)支持 API 设计,便于功能调用;9)配合自动化构建工具,优化项目管理;10)促进团队协作,明确模块归属。合理运用包能显著提升代码质量和开发效率。
|
2月前
|
Java 数据安全/隐私保护
Java 包(package)的使用详解
Java中的包(`package`)用于组织类和接口,避免类名冲突并控制访问权限,提升代码的可维护性和可重用性。通过`package`关键字定义包,创建相应目录结构即可实现。包可通过`import`语句导入,支持导入具体类或整个包。Java提供多种访问权限修饰符(`public`、`protected`、`default`、`private`),以及丰富的标准库包(如`java.lang`、`java.util`等)。合理的包命名和使用对大型项目的开发至关重要。
|
2月前
|
安全 Java 开发者
Java修饰符与封装:理解访问权限、行为控制与数据隐藏的重要性
Java中的修饰符和封装概念是构建健壯、易维护和扩展的Java应用程序的基石。通过合理利用访问权限修饰符和非访问修饰符,开发者能够设计出更加安全、灵活且高效的代码结构。封装不仅是面向对象编程的核心原则之一,也是提高软件项目质量和可维护性的关键策略。
20 1
|
1月前
|
Java 编译器
【Java】内部类
【Java】内部类
21 0
|
1月前
|
Java
java中的权限修饰符
java中的权限修饰符
|
3月前
|
Java
【Java基础面试三】、说一说你对Java访问权限的了解
这篇文章介绍了Java中的四种访问权限:private、default(无修饰符时的访问权限)、protected和public,以及它们分别在修饰成员变量/方法和类时的不同访问级别和规则。
【Java基础面试三】、说一说你对Java访问权限的了解
|
3月前
|
前端开发 Java 编译器
【前端学java】java中的package与import(3)
【8月更文挑战第9天】java中的package与import
26 2
【前端学java】java中的package与import(3)
|
3月前
|
Java Maven 数据库