1.包：其实就是文件夹，用于区分相同的类名

2.带包的类如何编译运行？
        方式1：A：用javac命令编译生成class文件
               B：手动创建包
               C：把class文件放入文件夹中
               D：用javac命令执行
        注意：类一定要用全路径名称，即带包使用  java com.Package Demo
        方式2：自动建包，编译的时候，让它自动建包
                javac -d. Package Demo.java    其中 -d后面的.表示在当前目录建包

3.访问权限修饰符：

        修饰符           本类                同一个包下                不同包下的子类                不同包下（无关的类）
        private                 Y                    N                                N                        N
        默认                 Y                    Y                                N                        N
        protected         Y                    Y                                Y                        N
        public                 Y                    Y                                Y                        Y
记住：成员变量一般用 private
      成员方法用  public

4.修饰符可以修饰的对象

        修饰符           类                成员变量                    成员方法            构造方法
        private                 Y                    Y                        Y                Y
        默认                 Y                    Y                        Y                Y
        protected                             Y                        Y                Y
        public                 Y                    Y                        Y                Y
        abstract         Y                                            Y               
        static                  Y                    Y                        Y               
        final                 Y                    Y                        Y

5.注意：常见规则
        A：以后所有的类都是 public 修饰，并且在一个java文件中只写一个类
        B：以后所有的成员变量都用 private 修饰
        C：以后所有的成员方法用 public 修饰，如果是抽象类或者接口用 public abstract修饰
        D：以后所有的构造方法用 public 修饰，如果类是工具类或者单例类，构造方法用 private 修饰

6.内部类：将一个类定义在另一个类里面，里面的类被称为内部类

     访问特点：内部类可以直接访问外部类，包括私有成员，而外部类访问内部成员必须创建对象

     内部类位置：
        A：成员位置上      成员内部类
        B：局部位置（方法中）    局部内部类

     成员内部类：直接使用格式
                        外部类名.内部类名 = new 外部类对象.new 内部类对象
                        Outer.Inner = new Outer().new Inner();
     成员内部类修饰符：
        A：private 为了安全考虑，常见用法
                例题：public class Body {
                        int a =10;
                        public void method() {
                                if(a>0){
                                        Heart h = new Heart();
                                        h.operator();
                                }
                        }
                        private class Heart{
                                public void operator() {
                                        System.out.println("可以做手术");
                                }
                        }
                      }

                      public class Doctor {
                        public static void main(String[] args) {
               
                                Body b = new Body();
                                b.method();
                        }
                     }

        B：static  为了方便，常见用法
             如果内部类是 static 修饰的：
                格式：   
                        外部类名.内部类名 = new 外部类名.内部类名（）;
                例题：public class Outer {
                        public static class Inner {
                                public void show() {
                                        System.out.println("show");
                                }
                        public static void show2() {
                                System.out.println("show2");
                        }
                        }
                      }

                      public class StaticUse {
                        public static void main(String[] args) {
                                Outer.Inner oi = new Outer.Inner();
                                oi.show();
                                oi.show2();
                                System.out.println("__________________________________");
               
                                Outer.Inner.show2();
                        }
                     }

7.局部内部类：方法中定义的类
        结论：局部内部类访问局部变量，该变量必须被final修饰

（*面试题）为什么？
        答案：局部变量会在方法调用完毕立马消失，而局部内部类还在使用局部变量，当方法消失后，这个方法区中的内容也就是说这个变量还必须存在，所以为了延长局部变量的生命周期，需要加final

8.匿名内部类：没有名字的内部类
        前提：必须存在一个类，抽象类或者接口
        格式：
                new 类名或接口名() ｛
                        重写接口中的方法
                        或者自己定义的新方法
                ｝;
例题：
//接口
public interface Inter {
        public abstract void method();
}
//局部内部类
public class NiMing {
        public void show() {
                new Inter() {
                        public void method(){
                                System.out.println("method");
                        }
                };
                new Inter() {
                        public void method(){
                                System.out.println("method");
                        }
                }.method();
        }
}
//测试类
public class NiMingTest {

        public static void main(String[] args) {
               
                NiMing nm = new NiMing();
                nm.show();
        }

}

        理解：是一个继承了类或者实现了接口的匿名子类对象

9.什么时候使用匿名内部类？
        一般来说，当接口或抽象类中的方法在三个以下的时候考虑使用匿名内部类
        当看到一个方法接收的参数是一个抽象类或者接口的时候，可以考虑使用匿名内部类实现
        总结：所有父类或者父接口出现的地方完全可以用子类对象
例题：用在形参上
//接口
public interface Animal {
        public abstract void eat();
}
//测试类
public class AnimalTest {

       
        public static void main(String[] args) {
               
                Test t = new Test();
                t.show(new Animal() {
                        public void eat() {
                                System.out.println("eat dog");
                        }
                });
        }

}

赞一个！！！

很详细，又学习了。支持一下

好全面，细心