使用方式一：”//1.创建一个实现Comparable接口的类：局部内部类

2.返回一个实现类的对象

方式二：//直接返回实现的对象
/*
 * 关于局部内部类的使用
 */
public class TestInnerClass1 {
	

}
class OutClass{
	//局部内部类
	public void method{
		class InnerClass{
			
		}
	}
	//常常使用一个方法使其返回值为某个类或接口的对象。而这个类或接口在在不创建
	public Comparable getComparable() {
		//1.创建一个实现Comparable接口的类：局部内部类
		class Mycomparable implements Comparable{

			@Override
			public int compareTo(java.lang.Object o) {
				// TODO Auto-generated method stub
				return 0;
			}
			
			
		}
		//2.返回一个实现类的对象
		
		return new Mycomparable();
	}
	public Comparable getComparable1() {
		//返回一个实现Comparable 
		return new Comparable() {

			@Override
			public int compareTo(java.lang.Object o) {
				// TODO Auto-generated method stub
				return 0;
			}
			
		};
	}
}

Java局部内部类的使用
package 内部类;

public class Outer {
    public void fun() { //外部类的成员方法
        class Inner {   //成员方法的局部内部类
            int a = 20;
            public void fun1(){ //内部类的方法
                System.out.println(a);
            }
        }
        Inner obj = new Inner();
        obj.fun1(); //调用局部内部类的方法
    }
}


package 内部类;

public class TEST {
    public static void main(String[] args) {
        Outer obj = new Outer();
        obj.fun();
    }
}


注：关于几种类的权限修饰符问题。
外部类：可用$public\ 或者(default)$

内部类：$public,protected,(default),private$都可。

局部内部类：只能用$(default)$，即什么都不能加。

定义
在方法或某个作用域内的内部类，称为局部内部类。匿名内部类就是一种局部内部类。
局部内部类基本形式：
class People{
public People() {
}
}
class Man{
public Man(){
}
public People Woman(){
class Woman extends People{   //局部内部类
int age =0;
}
return new Woman();
}
}
进阶操作
package com.Class;
public class People {
public double height = 5;
int age;
public People() {
}
void show() {
System.out.println(age);
}
}
package com.Class;
public class Man {
public Man() {}
int a = 10;
public People Woman(){//Woman类出来这个Woman函数则无法使用
int b = 20;
class Woman extends People{ //这一步是为了使得Woman能够在另一个类中实例化
int age = 30;
void show() {
System.out.println(age);
System.out.println(b);
}
@Override
public String toString() {
return "Woman [age=" + age + "] [height="+height + "]";
}
}
Woman woman = new Woman();
return woman ;
}
}
package com.Class;
public class PeopleTest {
public static void main(String[] args) {
Man aMan = new Man(); //new一个外部类
People womanPeople = aMan.Woman(); //通过外部类使用放在内部类的方法，而局部内部类只能在函数里面使用，但是可以通过返回对象用父类继承，从而在外部使用
womanPeople.show();
}
}
总结：
规则一：局部内部类类似方法的局部变量，所以在类外或者类的其他方法中不能访问这个内部类，但这并不代表局部内部类的实例和定义了它的方法中的局部变量具有相同的生命周期。
规则二：只能在方法内部使用，类(局部内部类)定义之后使用，不存在外部可见性问题，因此没有访问修饰符。
规则三：不能在局部内部类中使用可变的局部变量。
规则四：可以访问外围类的成员变量。如果是static方法，则只能访问static修饰的成员变量。
规则五：可以使用final 或 abstract修饰。

局部内部类定义位置
局部内部类是在方法中定义的类
局部内部类方式方式

局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用
该类可以直接访问外部类的成员，也可以访问方法内的局部变量

示例代码

public class Outer {

    private int num = 10;

    public void method() {
        int num2 = 20;
        class Inner {
            public void show() {
                System.out.println(num);
                System.out.println(num2);
            }
        }

        Inner i = new Inner();
        i.show();
    }
}

public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}