新加==内部类+包+代码块

内部类分为成员内部类与局部内部类。

我们定义内部类时，就是一个正常定义类的过程，同样包含各种修饰符、继承与实现关系等。在内部类中可以直接访问外部类的所有成员。

---

package com.oracle.demo02;
//普通的函数方法
//内部类

成员内部类，定义在外部类中的成员位置。与类中的成员变量相似，可通过外部类对象进行访问

public class Outer {
    int i=0;
    class inner{
        int i=1;
        public void show(){
            int i=2;
            //show方法直接打印  2
            System.out.println(i);
            //访问inner   1
            System.out.println(this.i);
            //outer下的i  0
            System.out.println(Outer.this.i);
        }
    }
}

public class Demo01 {
public static void main(String[] args) {
    //掉内部类
　　成员内部类定义：
    //外部类类名.内部类类名 变量名=new 外部类类名（）.内部类类名（）； 构造方法
    Outer.inner oi=new Outer().new inner();
    //变量名.方法名（）；
    oi.show();
    }
}

局部内部类

局部内部类，定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问

在外部类方法中，创建内部类对象，进行访问
public class Out {
    public void show(){
        //局部内部类
        class in{
            public void in(){
                System.out.println("这是局部类");
            }
        }
        //show下面的方法内部类，匿名对象
        new in().in();
    }
}

局部内部类测试

public class Demo02 {
public static void main(String[] args) {
    Out out=new Out();
    out.show();
        }

 匿名局部类：

1. 匿名内部类是没有访问修饰符的。
2. 使用匿名内部类时，这个new之后的类首先是要存在的，其次我们要重写new后的类的某个或某些方法。
3. 匿名内部类访问方法参数时也有和局部内部类同样的限制。
4. 匿名内部类没有构造方法。

//父类接口
public interface  Somking {
    public abstract void smoke();
}

public static void main(String[] args) {
    //匿名内部类，new父类或者接口  ，直接实现接口的实现类对象（直接重写） 多态 

//定义并创建该父类的子类对象，并用多态的方式赋值给父类引用变量

    Somking s=new Somking(){
//打印抽烟
        public void smoke() {
            System.out.println("抽烟");
        }
    };
    //多态父类有多少调多少
    s.smoke();

导包：

 类的简化访问

当我们要使用一个类时，这个类与当前程序在同一个包中（即同一个文件夹中），或者这个类是java.lang包中的类时通常可以省略掉包名，直接使用该类。

如：com.oracle包中有两个类，PersonTest类，与Person类。我们在PersonTest类中，访问Person类时，由于是同一个包下，访问时可以省略包名，即直接通过类名访问 Person。

类名 变量名 = new 类名();

Person p = new Person();

l 当我们要使用的类，与当前程序不在同一个包中（即不同文件夹中），要访问的类必须用public修饰才可访问。

package com.oracle02;

public class Person {}

1.1 import导包

我们每次使用类时，都需要写很长的包名。很麻烦，我们可以通过import导包的方式来简化。

可以通过导包的方式使用该类，可以避免使用全类名编写（即，包类.类名）。

导包的格式：

import 包名.类名;

 

当程序导入指定的包后，使用类时，就可以简化了。

 访问修饰符：

	public	protected	default	private
同一类中	√	√	√	√
同一包中(子类与无关类)	√	√	√
不同包的子类	√	√
不同包中的无关类	√

归纳一下：在日常开发过程中，编写的类、方法、成员变量的访问

l 要想仅能在本类中访问使用private修饰；

l 要想本包中的类都可以访问不加修饰符即可；

l 要想本包中的类与其他包中的子类可以访问使用protected修饰

l 要想所有包中的所有类都可以访问使用public修饰。

l 注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。

 代码块：

package com.oracle.demo05;
//构造方法
public class Person {
    
    public Person(){
        System.out.println("这是构造方法");
    }
    
    {
        System.out.println("这是构造代码块");
    }
    static {
        System.out.println("这是静态代码块");
    }
}

测试：

//构造代码块优先于构造方法
//new一次执行一次
public class Demo02 {
    public static void main(String[] args) {
        Person p=new Person();
        Person p2=new Person();
    }
}