12月11日报告

1.内部类

class Value{}

在类中再定义一个类

public void f1() {
    //使用Node对象保存了多个值,多个Node对象放在了一个Node[]数组中
    HashMap hashMap = new HashMap();
    hashMap.put("key0", "value0");
    hashMap.put("key1", "value1");
    hashMap.put("key2", "value2");
}

class Demo1 {
    //一个类中可以有什么成员,此类中依旧怎么定义
    //数组,一个位置保存一个值
    //有一个容器,一次性保存两个值
}

package com.langsin.test;

public class DiningRoom {
    private String egg="鸡蛋";
    private Cook cook=new Cook();

    class Cook{
        public void MakeFood(){
            //使用了外部类DiningRoom中定义的私有成员egg
            System.out.println("厨师使用"+egg+"炒了一份鸡蛋");
        }
    }
    /**
     * DiningRoom对外提供炒鸡蛋的功能
     * 实际该功能是由内部类Cook实现的
     */
    private void fireEgg(){
        this.cook.MakeFood();
    }
}

package com.langsin.test;

import java.awt.*;
import java.awt.event.*;
import java.util.Arrays;
import java.util.Comparator;

public class Demo1 {
    public static void main(String[] args) {

        class MyComparator implements Comparator<Integer> {
            @Override
            public int compare(Integer o1, Integer o2) {
                //小于返回负整数  等于返回0  大于返回正整数
                return -o1.compareTo(o2);
            }
        }


        Integer[] arr = {2, 3, 6, 5, 6, 7, 4, 8, 9, 7, 0, 6, 4, 5, 2, -1, 10, 2, 1};
        Arrays.sort(arr, new MyComparator());
        System.out.println(Arrays.toString(arr));

        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return -o1.compareTo(o2);
            }
        });
        System.out.println(Arrays.toString(arr));

        Button login = new Button();
        login.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("登陆成功");
            }
        });

        Button register = new Button();
        register.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("注册成功");
            }
        });
        TextField textField=new TextField();
        textField.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                super.mouseClicked(e);
            }
        });


    }
}

2.题目

(1)抽象类有构造方法

   抽象类不可以实例化

(2)抽象类有构造方法

     抽象类允许多继承

     接口方法可以有方法体

     接口没有提供构造方法

     接口中方法默认使用public abstract 修饰

     接口中变量默认使用public static final修饰

package com.langsin.test1;

public abstract interface Inter {
    //接口Inter
    void show();
}

package com.langsin.test1;
import java.lang.reflect.Method;
public abstract class Outer {
    //提供静态方法method
    public static Inter method() {

        //定义匿名内部类,对Inter接口定义的方法进行直接实现
        Inter inter = new Inter() {
            @Override
            public void show() {
                System.out.println("HelloWorld");
            }
        };

        //返回Inter类型变量inter
        return inter;

    }
}

package com.langsin.test1;

public class OuterDemo {
    public static void main(String[] args) {
        //通过Outer调用method方法,
        //返回Inter对象,调用Inter中的show方法
        Outer.method().show();
    }
}