【JAVA基础&高级】“面向对象篇” 知识点汇总

人{
    打开(冰箱){
        冰箱.开开();
    }

    抬起(大象){
        大象.进入(冰箱);
    }

    关闭(冰箱){
        冰箱.闭合();
    }

}

//实体对象
冰箱{
    //对象拥有的功能
    开开(){}
    闭合(){}
}

大象{
    进入(冰箱){}
}

Phone p = new Phone();
System.out.println(p)

new Phone().price = 1999;
new Phone().getPrice(); //0.0

public class InstanceTest {
	public static void main(String[] args) {
        PhoneMall mall = new PhoneMall();
		//匿名对象的使用
		mall.show(new Phone());
	}
}
class PhoneMall{
    public void show(Phone phone){
        //匿名对象通过形参的赋值，实现在方法中被多次调用
        phone.sendEmail(); 
        phone.playGame();
    }
}

void show(int x,char y,double z){} // no，参数的数量和类型相同

int show(int a,double c,char b){}	// yes

void show(int a,double c,char b){} 	// yes

boolean show(int c,char b){} 		// yes

void show(double c){} 		// yes

double show(int x,char y,double z){} // 参数的数量和类型相同

void shows(){double c} 		// no ，方法名不同

public class MethodArgsTest {
    public static void main(String[] args) {
        MethodArgsTest test = new MethodArgsTest();
        test.show(new String[]{"AA","BB","CC"});
        // 可变形参也可以接收一个数组
        test.show(new String[]{"AA","BB","CC"});
    }
    public void show(String ... strs){
        for(int i = 0;i < strs.length;i++){
            System.out.println(strs[i]);
        }
    }
}

public static void main(String[] args) {
	RecursionTest test = new RecursionTest();
    int sum = test.getSum(100);
    System.out.println(sum);
}
public int getSum(int n) {// 3
   if (n == 1) {
      return 1;
   } else {
      return n + getSum(n - 1);
   }
}

public static void main(String[] args) {
	RecursionTest test = new RecursionTest();
    int value = test.f(10);
    System.out.println(value);
}
public int f(int n){
    if(n == 0){
        return 1;
    }else if(n == 1){
        return 4;
    }else{
        return 2*f(n - 1) + f(n - 2);
    }
}

public class Person {
    private String name;
    private int age;
    private Date birthDate;
    public Person(String n, int a, Date d) {
        name = n;
        age = a;
        birthDate = d;
    }
    public Person(String n, int a) {
        name = n;
        age = a;
    }
    public Person(String n, Date d) {
        name = n;
        birthDate = d;
    }
    public Person(String n) {
        name = n;
        age = 30;
    }
}

class Person{ // 定义Person类
    private String name ;
    private int age ;
    public Person(){ // 无参构造器
        System.out.println("新对象实例化") ;
    }
    public Person(String name){
        this(); // 调用本类中的无参构造器
        this.name = name ;
    }
    public Person(String name,int age){
        this(name) ; // 调用有一个参数的构造器
        this.age = age;
    }
    public String getInfo(){
        return "姓名： " + name + "，年龄： " + age ;
    }
}

public class Test{
    public static void main(String[] args) {
        Student stu = new Student();
        stu.eat() //可以正常继承并且调用
        stu.sleep() //由于该方法在父类中使用private进行修饰，无法调用
    }
}
public class Person{
    String name;
    private int age;
    
    private void sleep(){	//私有的
        System.out.println("睡觉");
    }
    public void eat(){		//公共的
        System.out.println("吃饭");
    }
}
public class Student extends Person{
    String major;
    public void study(){
        System.out.println("学习");
    }
}

public class Person { 
    public String name; 
    public int age;
    public String getInfo() {
        return "Name: "+ name + "\n" +"age: "+ age;
    }
}

public class Student extends Person {
    public String school;
    public String getInfo() { //重写方法
        return "Name: "+ name + "\nage: "+ age
            + "\nschool: "+ school;
    }
    public static void main(String args[]){
        Student s1=new Student();
        s1.name="Bob";
        s1.age=20;
        s1.school="school2";
        System.out.println(s1.getInfo()); 
    }
}

Person p1=new Person();
//调用Person类的getInfo()方法
p1.getInfo();
Student s1=new Student();
//调用Student类的getInfo()方法
s1.getInfo();

class protected Person {
    String name = "张三"; 
    protected int age;
    public String getInfo() {
        return "Name: " + name + "\nage: " + age;
    }
}
class Student extends Person {
    protected String name = "李四";
    private String school = "New Oriental";
    public String getSchool() {
        return school;
    }
    public String getInfo() {
        //使用super调用父类的方法
        return super.getInfo() + "\nschool: " + school;
    }}
public class StudentTest {
    public static void main(String[] args) {
        Student st = new Student();
        System.out.println(st.getInfo());
    }
}

public class Person {
    private String name;
    private int age;
    private Date birthDate;
    public Person(String name, int age, Date d) {
        this.name = name;
        this.age = age;
        this.birthDate = d;
    }
    public Person(String name, int age) {
        this(name, age, null);
    }
    public Person(String name, Date d) {
        this(name, 30, d);
    }
    public Person(String name) {
        this(name, 30);
    }
}
public class Student extends Person {
    private String school;
    public Student(String name, int age, String s{
        super(name, age);
        school = s;
    }
    public Student(String name, String s) {
        super(name);
        school = s;
    }
    // 编译出错: no super(),系统将调用父类无参数的构造器。
    public Student(String s) {
        school = s;
    }
}

class Creature {
    public Creature() {
        System.out.println("Creature无参数的构造器");
    }
}

class Animal extends Creature {
    public Animal(String name) {
        System.out.println("Animal带一个参数的构造器，该动物的name为" + name);
    }

    public Animal(String name, int age) {
        this(name);
        System.out.println("Animal带两个参数的构造器，其age为" + age);
    }
}

public class Wolf extends Animal {
    public Wolf() {
        super("灰太狼", 3);
        System.out.println("Wolf无参数的构造器");
    }

    public static void main(String[] args) {
        new Wolf();
    }
}

//对象的多态性：父类的引用指向子类的对象
Person p2 = new Man();
//多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法（虚拟方法调用）
p2.eat();
p2.walk();

public class AnimalTest {
	public static void main(String[] args) {
		AnimalTest test = new AnimalTest();
		test.func(new Dog());
	}
	public void func(Animal animal){
        //Animal animal = new Dog();
		animal.eat();
		animal.shout();
	}
}

class Animal{
	public void eat(){
		System.out.println("动物：进食");
	}
	
	public void shout(){
		System.out.println("动物：叫");
	}
}

class Dog extends Animal{
	public void eat(){
		System.out.println("狗吃骨头");
	}
	
	public void shout(){
		System.out.println("汪！汪！汪！");
	}
	
	public void watchDoor(){
		System.out.println("看门");
	}
}

class Cat extends Animal{
	public void eat(){
		System.out.println("猫吃鱼");
	}
	
	public void shout(){
		System.out.println("喵！喵！喵！");
	}
}

public static void main(String[] args) {

   AnimalTest test = new AnimalTest();
   test.func(new Dog());
   System.out.println("==================分割线====================");
   test.func(new Cat());
}

class Driver{
	public void doData(Connection conn){
		conn.method1();  //数据库连接的一些相关操作的方法（假设）
		conn.method2();
		conn.method3();
	}
}

Driver driver = new Driver();
driver.doData(new MySQlConnection());

Driver driver = new Driver();
driver.doData(new OracleConnection());

import java.util.Random;

class Animal  {
	protected void eat() {
		System.out.println("animal eat food");
	}
}
class Cat  extends Animal  {
	protected void eat() {
		System.out.println("cat eat fish");
	}
}
class Dog  extends Animal  {
	public void eat() {
		System.out.println("Dog eat bone");
	}
}
class Sheep  extends Animal  {
	public void eat() {
		System.out.println("Sheep eat grass");
	}
}

public class InterviewTest {
	public static Animal  getInstance(int key) {
		switch (key) {
		case 0:
			return new Cat ();
		case 1:
			return new Dog ();
		default:
			return new Sheep ();
		}
	}
	public static void main(String[] args) {shii
		int key = new Random().nextInt(3);
		System.out.println(key);
		Animal  animal = getInstance(key);
		animal.eat();
	}
}

public class PersonTest {
    public static void main(String[] args) {
		Person p2 = new Man();
        System.out.println(p2.id); //1001
    }
}
public class Person {
    int id = 1001;
}
public class Man {
    int id = 1002;
}

Person p2 = new Man();
Man m1 = (Man)p2;
m1.earnMoney();
m1.isSmoking = true;

Woman w1 = (Woman)p2;  //编译通过
w1.goShopping();  //执行时出错，出现ClassCastException的异常。

if(p2 instanceof Woman){
    Woman w1 = (Woman)p2;
    w1.goShopping();
    System.out.println("******Woman******");
}

if(p2 instanceof Man){
    Man m2 = (Man)p2;
    m2.earnMoney();
    System.out.println("******Man******");
}

public class Customer {

	private String name;
	private int age;

    //...... 这里省略get set方法以及构造方法
    
	//重写的原则：比较两个对象的实体内容(即：name和age)是否相同
	//手动实现equals()的重写
	@Override
	public boolean equals(Object obj) {
		if (this == obj) {
            return true;
        }
		if(obj instanceof Customer){
			Customer cust = (Customer) obj;
            //对比每个属性的值
			return this.age == cust.age && this.name.equals(cust.name);
		}else{
			return false;
		}
	}

Object o1 = true ? new Integer(1) : new Double(2.0);
System.out.println(o1);

Object o2;
if (true)
    o2 = new Integer(1);
else
    o2 = new Double(2.0);
System.out.println(o2);

@Test
public void test3() {
   Integer i = new Integer(1);
   Integer j = new Integer(1);
   System.out.println(i == j);//false
   
   Integer m = 1;
   Integer n = 1;
   System.out.println(m == n);//true

   Integer x = 128;	//相当于new了一个Integer对象
   Integer y = 128;	//相当于new了一个Integer对象
   System.out.println(x == y);//false
}

@Override
public boolean equals(Object obj) {
    if (this == obj) {
        return true;
    }
    if(obj instanceof Customer){
        Customer cust = (Customer) obj;
        //对比每个属性的值
        return this.age == cust.age && this.name.equals(cust.name);
    }else{
        return false;
    }
}

public class StaticTest {
	public static void main(String[] args) {
		
		Chinese.nation = "中国";
		
		
		Chinese c1 = new Chinese();
		c1.name = "姚明";
		c1.age = 40;
		c1.nation = "CHN";
		
		Chinese c2 = new Chinese();
		c2.name = "马龙";
		c2.age = 30;
		c2.nation = "CHINA"; //使用c2调用该属性并修改值
		System.out.println(c1.nation);  //使用c1对象输出该属性的值，结果为CHINA
    }
}

class Chinese{
	String name;
	int age;
	static String nation;
}

public class StaticTest {
	public static void main(String[] args) {
		Chinese.show();
		//Chinese.eat();  //编译不通过
		//Chinese.info();
	}
}
class Chinese{
    String name;
    int age;
    static String nation;
    public void eat(){
        System.out.println("中国人吃中餐");
        //调用非静态结构
        this.info();
        System.out.println("name :" +name);
        //调用静态结构
        walk();
        System.out.println("nation : " + nation);
    }
    public static void show(){
        System.out.println("我是一个中国人！");
        //不能调用非静态的结构
        //    eat();
        //    name = "Tom";
        //可以调用静态的结构
        System.out.println(Chinese.nation);
        walk();
    }
}

public class SingletonTest1 {
    public static void main(String[] args) {
        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();
        System.out.println(bank1 == bank2);  //同一个对象，所以结果为true
    }
}

//饿汉式
class Bank{
    //1.私有化类的构造器
    private Bank(){

    }
    //2.内部创建类的对象，要求此对象也必须声明为静态的
    private static Bank instance = new Bank();

    //3.提供公共的静态的方法，返回类的对象
    public static Bank getInstance(){
        return instance;
    }
}

public class SingletonTest2 {
	public static void main(String[] args) {	
		Order order1 = Order.getInstance();
		Order order2 = Order.getInstance();
		System.out.println(order1 == order2);
	}
}
class Order{
	//1.私有化类的构造器
	private Order(){
		
	}
	//2.声明当前类对象，没有初始化，此对象也必须声明为static的
	private static Order instance = null;
	
	//3.声明public、static的返回当前类对象的方法
	public static Order getInstance(){
		if(instance == null){
			instance = new Order();
		}
		return instance;
	}
	
}

public class BlockTest {
    public static void main(String[] args) {
        String desc = Person.desc;
        System.out.println(desc);

        Person p1 = new Person();
        Person p2 = new Person();
        System.out.println(p1.age);

        Person.info();
    }
}
class Person{
    //属性
    String name;
    int age;
    static String desc = "我是一个人";
    //构造器
    public Person(){

    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    //非static的代码块
    {
        System.out.println("hello, block - 2");
    }
    {
        System.out.println("hello, block - 1");
        //调用非静态结构
        age = 1;
        eat();
        //调用静态结构
        desc = "我是一个爱学习的人1";
        info();
    }
    //static的代码块
    static{
        System.out.println("hello,static block-2");
    }
    static{
        System.out.println("hello,static block-1");
        //调用静态结构
        desc = "我是一个爱学习的人";
        info();
        //不可以调用非静态结构
        //		eat();
        //		name = "Tom";
    }

    //方法
    public void eat(){
        System.out.println("吃饭");
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    public static void info(){
        System.out.println("我是一个快乐的人！");
    }
}

hello,static block-2
hello,static block-1
我是一个快乐的人！
我是一个爱学习的人
hello, block - 2
hello, block - 1
吃饭
我是一个快乐的人！
hello, block - 2
hello, block - 1
吃饭
我是一个快乐的人！
1
我是一个快乐的人！

public class JDBCUtils {
    private static DataSource dataSource = null;
    static{
        InputStream is = null;
        try {
            is = DBCPTest.class.getClassLoader().getResourceAsStream("dbcp.properties");
            Properties pros = new Properties();
            pros.load(is);
            //调用BasicDataSourceFactory的静态方法，获取数据源。
            dataSource = BasicDataSourceFactory.createDataSource(pros);
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            if(is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }	
    }
    //使用DBCP数据库连接池实现数据库的连接
    public static Connection getConnectionAccess() throws SQLException{
        Connection conn = dataSource.getConnection();
        System.out.println(conn);
        return conn;
    }

}

abstract class Creature{
    public abstract void breath();
}

abstract class Person extends Creature{
    String name;
    int age;

    public Person(){

    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    //不是抽象方法：
    //	public void eat(){
    //		
    //	}

    //抽象方法
    public abstract void eat();

    public void walk(){
        System.out.println("人走路");
    }
}
class Student extends Person{

    public Student(String name,int age){
        super(name,age);
    }
    public Student(){
    }

    public void eat(){
        System.out.println("学生多吃有营养的食物");
    }

    @Override
    public void breath() {
        System.out.println("学生应该呼吸新鲜的没有雾霾的空气");
    }
}

new 抽象类名(){
    @Overrride
    public void 方法1(){

    }
    @Overrride
    public void 方法2(){
		
    }
}

/*
 * 抽象类的匿名子类
 * 
 */
public class PersonTest {

    public static void main(String[] args) {
        method(new Student());//匿名对象
        Worker worker = new Worker();
        method1(worker);//非匿名的类非匿名的对象
        method1(new Worker());//非匿名的类匿名的对象
        System.out.println("********************");
        //创建了一匿名子类的对象：p
        Person p = new Person(){
            @Override
            public void eat() {
                System.out.println("吃东西");
            }
            @Override
            public void breath() {
                System.out.println("好好呼吸");
            }
        };
        method1(p);
        System.out.println("********************");
        
        //创建匿名子类的匿名对象
        method1(new Person(){
            @Override
            public void eat() {
                System.out.println("吃好吃东西");
            }
            @Override
            public void breath() {
                System.out.println("好好呼吸新鲜空气");
            }
        });
    }
    public static void method1(Person p){
        p.eat();
        p.breath();
    }
    public static void method(Student s){
        
    }
}

class Worker extends Person{
    @Override
    public void eat() {}
    @Override
    public void breath() {}
}

//抽象类的应用：模板方法的设计模式
public class TemplateMethodTest {
    public static void main(String[] args) {
        BankTemplateMethod btm = new DrawMoney();
        btm.process();

        BankTemplateMethod btm2 = new ManageMoney();
        btm2.process();
    }
}
abstract class BankTemplateMethod {
    // 具体方法
    public void takeNumber() {
        System.out.println("取号排队");
    }
    public abstract void transact(); // 办理具体的业务 //钩子方法

    public void evaluate() {
        System.out.println("反馈评分");
    }

    // 模板方法，把基本操作组合到一起，子类一般不能重写
    public final void process() {
        this.takeNumber();

        this.transact();// 像个钩子，具体执行时，挂哪个子类，就执行哪个子类的实现代码

        this.evaluate();
    }
}

//业务子类，实现各自业务的办理流程
class DrawMoney extends BankTemplateMethod {
    public void transact() {
        System.out.println("我要取款！！！");
    }
}

class ManageMoney extends BankTemplateMethod {
    public void transact() {
        System.out.println("我要理财！我这里有2000万美元!!");
    }
}

public interface Runner {
    int ID = 1;
    void start();
    public void run();
    void stop();
}

public interface Runner {
    public static final int ID = 1;
    public abstract void start();
    public abstract void run();
    public abstract void stop();
}

public class InterfaceTest {
	public static void main(String[] args) {
		System.out.println(Flyable.MAX_SPEED);
		System.out.println(Flyable.MIN_SPEED);
//		Flyable.MIN_SPEED = 2;
		Plane plane = new Plane();
		plane.fly();
	}
}

interface Flyable{
	//全局常量
	public static final int MAX_SPEED = 7900;//第一宇宙速度
	int MIN_SPEED = 1;//省略了public static final
	//抽象方法
	public abstract void fly();
	//省略了public abstract
	void stop();
}

interface Attackable{
	void attack();
}

class Plane implements Flyable{
	@Override
	public void fly() {
		System.out.println("通过引擎起飞");
	}
	@Override
	public void stop() {
		System.out.println("驾驶员减速停止");
	}
}

abstract class Kite implements Flyable{

	@Override
	public void fly() {
		
	}
	
}

class Bullet extends Object implements Flyable,Attackable,CC{

	@Override
	public void attack() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void fly() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void stop() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void method1() {
		// TODO Auto-generated method stub
		
	}
    
	@Override
	public void method2() {
		// TODO Auto-generated method stub
		
	}
}

public class USBTest {
	public static void main(String[] args) {
		
		Computer com = new Computer();
		//1.创建了接口的非匿名实现类的非匿名对象
		Flash flash = new Flash();
		com.transferData(flash);
		
		//2. 创建了接口的非匿名实现类的匿名对象
		com.transferData(new Printer());
		
		//3. 创建了接口的匿名实现类的非匿名对象
		USB phone = new USB(){

			@Override
			public void start() {
				System.out.println("手机开始工作");
			}

			@Override
			public void stop() {
				System.out.println("手机结束工作");
			}
			
		};
		com.transferData(phone);
        
		//4. 创建了接口的匿名实现类的匿名对象
		
		com.transferData(new USB(){
			@Override
			public void start() {
				System.out.println("mp3开始工作");
			}

			@Override
			public void stop() {
				System.out.println("mp3结束工作");
			}
		});
	}
}

class Computer{
	public void transferData(USB usb){//USB usb = new Flash();
		usb.start();
		System.out.println("具体传输数据的细节");
		usb.stop();
	}
	
}

interface USB{
	//常量：定义了长、宽、最大最小的传输速度等
	
	void start();
	
	void stop();
	
}

class Flash implements USB{

	@Override
	public void start() {
		System.out.println("U盘开启工作");
	}

	@Override
	public void stop() {
		System.out.println("U盘结束工作");
	}
	
}

class Printer implements USB{
	@Override
	public void start() {
		System.out.println("打印机开启工作");
	}

	@Override
	public void stop() {
		System.out.println("打印机结束工作");
	}
	
}

/*
 * 接口的应用：代理模式
 * 
 */
public class NetWorkTest {
	public static void main(String[] args) {
		BrowseGoogle browseGoogle = new BrowseGoogle();
		BrowseFireFox browseFireFox = new BrowseFireFox();

		//通过谷歌浏览器访问网络
		ProxyBrowse proxyBrowseGoogle = new ProxyBrowse(browseGoogle);
		proxyBrowseGoogle.browse();

		//通过浏览器B访问网络
		ProxyBrowse proxyBrowseFireFox = new ProxyBrowse(browseFireFox);
		proxyBrowseFireFox.browse();
	}
}

interface NetWork{
	//浏览网页
	public void browse();
}

//被代理类A：服务提供商
class BrowseGoogle implements NetWork{
	@Override
	public void browse() {
		System.out.println("谷歌浏览器：正在访问网页");
	}
}
//被代理类B：服务提供商
class BrowseFireFox implements NetWork{
	@Override
	public void browse() {
		System.out.println("火狐浏览器：正在访问网页");
	}
}
//代理类：需求方
class ProxyBrowse implements NetWork{
	private NetWork work;

	public ProxyBrowse(NetWork work){
		this.work = work;
	}

	public void check(){
		System.out.println("网上冲浪之前的检查工作");
	}

	public void end(){
		System.out.println("关机，结束网上冲浪");
	}
	@Override
	public void browse() {
		this.check();
		work.browse();
		this.end();
	}
}

网上冲浪之前的检查工作
谷歌浏览器：正在访问网页
关机，结束网上冲浪
网上冲浪之前的检查工作
火狐浏览器：正在访问网页
关机，结束网上冲浪

public class SubClassTest {
	public static void main(String[] args) {
		SubClass s = new SubClass();
//		s.method1();
//		SubClass.method1();
		//知识点1
		CompareA.method1();
		//知识点2 
		s.method2();
		//知识点3、知识点4
		s.method3();
		
	}
}
class SubClass extends SuperClass implements CompareA,CompareB{
	public void method2(){
		System.out.println("SubClass：上海");
	}
	public void method3(){
		System.out.println("SubClass：深圳");
	}
	//知识点5
	public void myMethod(){
		method3();//调用自己定义的重写的方法
		super.method3();//调用的是父类中声明的
		//调用接口中的默认方法
		CompareA.super.method3();
		CompareB.super.method3();
	}
}
public class SuperClass {
	public void method3(){
		System.out.println("SuperClass:北京");
	}	
}
public interface CompareA {
   
   //静态方法
   public static void method1(){
      System.out.println("CompareA:北京");
   }
   //默认方法
   public default void method2(){
      System.out.println("CompareA：上海");
   }
   
   default void method3(){
      System.out.println("CompareA：上海");
   }
}

public interface CompareB {
	default void method3(){
		System.out.println("CompareB：上海");
	}
}

interface Filial {// 孝顺的
	default void help() {
		System.out.println("老妈，我来救你了");
	}
}

interface Spoony {// 痴情的
	default void help() {
		System.out.println("媳妇，别怕，我来了");
	}
}

class Father{
	public void help(){
		System.out.println("儿子，救我媳妇！");
	}
}

class Man extends Father implements Filial, Spoony {

	@Override
	public void help() {
		System.out.println("我该救谁呢？");  //自定义的
		Filial.super.help();  //救你的老妈
		Spoony.super.help();  //救媳妇
	}

	public static void main(String[] args) {
		Man man = new Man();
		man.help(); //如果Man未实现help方法，则默认调用父类的同名方法
	}
}

public class Outer {
    private int s = 111;
    public class Inner {
        private int s = 222;
        public void mb(int s) {
            System.out.println(s); // 局部变量s
            System.out.println(this.s); // 内部类对象的属性s
            System.out.println(Outer.this.s); // 外部类对象属性s
        }
    }
    public static void main(String args[]) {
        Outer a = new Outer();
        Outer.Inner b = a.new Inner();
        b.mb(333);
    }
}

class 外部类{
    方法(){
        class 局部内部类{
        }
    } {
        class 局部内部类{
        }
    }
}

public class InnerClassTest1 {
    //开发中很少见
    public void method(){
        //局部内部类
        class AA{
        }
    }
    //返回一个实现了Comparable接口的类的对象
    public Comparable getComparable(){

        //创建一个实现了Comparable接口的类:局部内部类
        //方式一：
        //		class MyComparable implements Comparable{
        //
        //			@Override
        //			public int compareTo(Object o) {
        //				return 0;
        //			}
        //			
        //		}
        //		
        //		return new MyComparable();

        //方式二：
        return new Comparable(){

            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };
    }
}

interface A{
    public abstract void fun1();
}
public class Outer{
    public static void main(String[] args) {
        new Outer().callInner(new A(){
            //接口是不能new但此处比较特殊是子类对象实现接口，只不过没有为对象取名
            public void fun1() {
                System.out.println(“implement for fun1");
                                   }
                                   });// 两步写成一步了
            }
            public void callInner(A a) {
                a.fun1();
            }
        }
}