专栏首页阿Q说代码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; 
•   }

修饰符

权限修饰符的访问权限
  • 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 Demo1_InnerClass {
•       public static void main(String[] args) {
•           //外部类名.内部类名 对象名 = 外部类名.内部类对象;
•           Outer.Inner oi = new Outer.Inner();
•           oi.method();

•           Outer.Inner2.print();   //直接访问静态内部类里面的静态方法
•       }
•   }

•   class Outer {
•       static class Inner {        //静态成员内部类
•           public void method() {
•               System.out.println("method");
•           }
•       }

•       static class Inner2 {       //静态成员内部类
•           public static void print() {        //静态方法
•               System.out.println("print");
•           }
•       }
•   }
内部类对象访问当前外部类对象的成员变量
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说代码(AQ_Shuo),作者:阿Q

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2019-01-14

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Java-权限修饰&内部类

    1、在类的成员位置,和成员变量以及成员方法所在的位置是一样的 2、在内部类当中,可以直接访问外部类的成员,包括私有成员 修饰符:

    DataScience
  • 【Java_10】final 关键字、权限修饰符、内部类

    | | 同一个类中 | 同一个包中 | 不同包的子类 | 不同包的无关类 | | public | ✓ | ✓ | ✓ | ✓ | | protected ...

    用户8250147
  • JAVA入门学习四

    描述:有个这个关键字就是让有包的类对调用者可见,不用写全类名了; 比如我们前面在进行Scanner类示例化的对象来接收用户输入;

    WeiyiGeek
  • Java 小白成长记 · 第 5 篇《Java 是如何实现封装的 — 图解访问修饰符》

    在第一篇文章 Java 小白成长记 · 第 1 篇《万物皆对象》 中我们就已经了解到,面向对象具有四大基本特点:

    飞天小牛肉
  • Java基础:六、访问权限修饰词 (2)

    访问权限控制的等级,从最大权限到最小权限依次为:public、protected、包访问权限(没有关键词)和private

    桑鱼
  • 访问权限控制

    访问权限控制又称「隐藏具体实现」,也就是说,我们可以通过它来决定某个类或者类中的成员在程序中的可见范围。例如,被修饰为 public 的元素在全局范围可见,而被...

    Single
  • Java基础笔记10

    dreamkong
  • 阶段01Java基础day10面向对象05

    声明:本文为原创,作者为 对弈,转载时请保留本声明及附带文章链接:http://www.duiyi.xyz/c%e5%ae%9e%e7%8e%b0%e9%9b%...

    对弈
  • 论 Java 的访问权限

    Java中成员访问权限 Java中的访问权限控制符有四个: 作用域_____当前类____同一package___子孙类____其他package publi...

    房上的猫
  • 面向对象的三大特性讲义

    多个类中存在相同属性和行为时, 将这些内容抽取到单独的一个类中, 那么这多个类就无需再定义这些属性和行为了, 只要继承那个类即可. 这个关系, 就叫继承.

    用户8870853
  • 夯实Java基础系列5:Java文件和Java包结构

    本系列文章将整理到我在GitHub上的《Java面试指南》仓库,更多精彩内容请到我的仓库里查看

    黄小斜学Java
  • 一文读懂 Java 文件和包结构,解读开发中常用的 jar 包

    本系列文章将整理到我在GitHub上的《Java面试指南》仓库,更多精彩内容请到我的仓库里查看

    Java技术江湖
  • Java中的访问控制权限

    简介 Java中为什么要设计访问权限控制机制呢?主要作用有两点: (1)为了使用户不要触碰那些他们不该触碰的部分,这些部分对于类内部的操作时必要的,但是它并不属...

    静默虚空
  • JAVA基础复习day-01

    byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。

    阮键
  • Java几个重要关键字的使用

    跟类相关:package(包) class(类) abstract(抽象) extends(继承) implements(实现) interface(接口)

    用户7886150
  • 大数据技术之_16_Scala学习_05_面向对象编程-中级

    1、scala 进行 package 打包时,可以有如下形式。【案例演示+反编译查看】

    黑泽君
  • Java 面向对象一览

    学 Java 的朋友都知道,Java 是一门典型的面向对象的高级程序设计语言,但有些朋友可能不清楚面向对象在 Java 中是怎么体现的。这篇文章就向大家分享下 ...

    蜗牛互联网
  • Java编程思想第五版(OnJava8)第七章 - 封装

    所有优秀的作者——包括那些编写软件的人——都知道一件好的作品都是经过反复打磨才变得优秀的。如果你把一段代码置于某个位置一段时间,过一会重新来看,你可能发现更好的...

    JavaEdge
  • *Java中的关键字*

    关键字是Java中的一些具有特定含义的单词,定义的变量名不能和关键字冲突。(下面按如下图所示的顺序进行学习)

    一半是我

扫码关注云+社区

领取腾讯云代金券