匿名对象，内部类，包，访问修饰符，代码块

 匿名对象的概念

匿名对象是指创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。

如：已经存在的类：

public class Person{
    public void eat(){
        System.out.println();
　　}
}

//创建一个普通对象
Person p = new Person();
//创建一个匿名对象
new Person();

匿名对象特点：

　　匿名对象在没有指定其引用变量时，只能使用一次。

new Person().eat(); 创建一个匿名对象，调用eat方法
new Person().eat(); 想再次调用eat方法，重新创建了一个匿名对象

　　  匿名对象可以作为方法接收的参数、方法返回值使用

class Demo {
    public static Person getPerson(){
        //普通方式
        //Person p = new Person();    
        //return p;
        
        //匿名对象作为方法返回值
        return new Person(); 
    }
    
    public static void method(Person p){}
}

测试类：

class Test {
    public static void main(String[] args) {
        //调用getPerson方法，得到一个Person对象
        Person person = Demo.getPerson();
        
        //调用method方法
        Demo.method(person);
        //匿名对象作为方法接收的参数
        Demo.method(new Person());
    }
}

 内部类概念

 　　将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类。

内部类的使用：

　　在描述事物时，若一个事物内部还包含其他可能包含的事物，比如在描述汽车时，汽车中还包含这发动机，这时发动机就可以使用内部类来描述。

class 汽车 { //外部类
    class 发动机 { //内部类
}
}

内部类的分类

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

注意：　　在内部类中可以直接访问外部类的所有成员。

成员内部类：

定义格式：

class 外部类 { 
    修饰符 class 内部类 {
        //其他代码
　　}
}

访问方式：

外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

例子;

package com.oricle.neilei;

public class Outer {
    private int a=1;
    class Inner{
        private int a=2;
        public void in(){
            int a=3;
            System.out.println(a);//访问内部类方法中的变量
            System.out.println(this.a);//访问内部类变量
            System.out.println(Outer.this.a);//访问外部类变量
            System.out.println("内部类");
        }
    }
}

测试类，访问内部类：

package com.oricle.neilei;

public class Test {

    public static void main(String[] args) {
        
        Outer.Inner o =new Outer().new Inner();
        o.in();
    }

}

结果演示：

局部内部类：
定义格式：

class 外部类 { 
    修饰符 返回值类型 方法名(参数) {
　　class 内部类 {
//其他代码
    }
　　}
}

访问方式：
　　在外部类方法中，创建内部类对象，进行访问

例子：

package com.oricle.neilei;

//外部类
public class JuOuter {
    //外部类方法
    public void Out(){
        //局部内部类
        class Inner{
            //内部类方法
            public void in(){
                System.out.println("内部类方法");
            }
        }
        Inner i=new Inner();//创建局部内部类对象
        i.in();
    }
}

测试类：

package com.oricle.neilei;

public class DEMO {

    public static void main(String[] args) {
        
        JuOuter j=new JuOuter();
        j.Out();
    }

}

结果：

匿名内部类

　　匿名内部类是创建某个类型子类对象的快捷方式。

格式：

new 父类或接口(){
    //进行方法重写
};

例子：

package com.oricle.neilei;

public interface Smoker {
    public abstract void smoke();
}

测试类：

package com.oricle.neilei;

public class stest {

    public static void main(String[] args) {
        
        new Smoker(){
            public void smoke(){
                System.out.println("抽烟");
            }
        }.smoke();
    }

}