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();
}
}
匿名内部类可以重写多个方法, 但是一般开发中就让其重写一个方法。
匿名内部类是不能向下转型的,因为没有子类类名，所以不能使用匿名内部类里面的特有方法。
当我们看到一个方法的参数类型是抽象类或者接口的时候， 我们调用这个方法的时候，可以考虑用匿名内部类来实现。
interface Inter {
void show();
}
class Outer {
//补齐代码
}
class OuterDemo {
public static void main(String[] args) {
Outer.method().show();
}
}
今天学习了package和导包（import）之后是不是觉得编译步骤很复杂啊？下节我们将学习用Eclipse来编译运行程序。想了解更多学习知识，请关注微信公众号“阿Q说”，获取更多学习资料吧！你也可以后台留言说出你的疑惑，阿Q将会在后期的文章中为你解答。每天学习一点点，每天进步一点点。
原文作者：阿Q说代码；如有侵权，请联系管理员删除。
