day04面向对象高级

1.代码块

类的五大成分之一(成员变量,构造器,方法,的代码块,内部类)

静态代码块

static{}

特点:类加载时自动执行,由于类只会加载一次,所以静态代码块也只会执行一次

作用:完成类的初始化,对静态变量的初始化

public class StaticCodeDemo {
   //静态代码块
    static {
        System.out.println("静态代码块");
    }
    public static void main(String[] args) {
        System.out.println("main方法");
    }
}

实例代码块 

{}

特点:每次创建对象时,执行实例代码块,并在构造器前执行

作用:和构造器一样,都是用来完成对象的初始化的,例如:对实例变量进行初始化赋值 

//实例代码块
public class CodeDemo {
    {
        System.out.println("实例代码块");
    }

    public static void main(String[] args) {
        System.out.println("main方法");
        new CodeDemo();
        new CodeDemo();
            
    }
}

2.内部类

如果一个类定义在另一个类的内部,这个类就是内部类

成员内部类

成员内部类中可以直接访问外部类的静态成员

public class Outer {
    private static String name = "angel";
    private int age = 18;
    public static void method(){
        System.out.println("method方法");
    }
    public class Inner{
        public void show(){
            System.out.println(name);
            System.out.println(age);
            System.out.println("show方法");
            method();
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();
        inner.show();
    }
}

静态内部类

静态内部类中可以直接访问外部类的静态成员

静态内部类中不可以访问外部类的实例成员

public class Outer {
    public static class Inner{
        public void show(){
            System.out.println("静态内部类show方法");
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner();
    }
}

局部内部类

局部内部类定义在方法中,代码块中,构造器中

▲匿名内部类

特殊的局部内部类

所谓匿名:程序员不需要为这个类声明名字,默认有个隐藏的名字

new 类/接口(参数值...){

      类体(一般是方法重写)

}

特点:匿名内部类本质是一个子类,同时会自己创建一个子类对象

 作用:用于更方便的创建一个子类对象

public class Test {
    public static void main(String[] args) {
    Animal cat = new Cat();
    cat.cry();
    Animal dog = new Animal() {
        @Override
        public void cry() {
            System.out.println("汪汪汪");
        }
    };
    dog.cry();
    }
}

 常见使用形式

通常作为一个对象参数传输给方法

需求:学生老师参加游泳比赛

public class Test2 {
    public static void main(String[] args) {
        Swim p = new Swim(){
            @Override
            public void swimming()
            {
                System.out.println("学生游泳");
            }
        };
        p.swimming();
       go(new Swim() {
           @Override
           public void swimming() {
               System.out.println("老师游泳");
           }
       });



    }
    public static void go(Swim s){
        System.out.println("==========开始=============");
        s.swimming();
    }
    interface Swim{
        void swimming();
    }
}

使用场景:

匿名内部类在开发中的真实使用场景

调用被人提供的方法实现需求时,这个方法正好让我们传输一个匿名内部类对象给其使用

public class Test3 {
    public static void main(String[] args) {
        //需求:创建一个登录窗口,窗口只有一个登录按钮
        JFrame win = new JFrame("登录窗口");
        JPanel jp = new JPanel();
        win.add(jp);

        JButton jb = new JButton("登录");
        jp.add(jb);
        //给按钮添加一个点击事件的监听器对象
        jb.addActionListener(new ActionListener(){
            @Override
            public void actionPerformed(java.awt.event.ActionEvent e) {
                System.out.println("点击了登录按钮");
            }
        });

        win.setSize(400,300);//设置窗口大小
        win.setLocationRelativeTo(null);//居中显示
        win.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//退出程序
        win.setVisible(true);//显示窗口
    }
}

使用comparator接口的匿名内部类实现对数组进行排序

public class Test4 {
    public static void main(String[] args) {
        Student[] s = new Student[3];
        s[0] = new Student("张三", 19, 100);
        s[1] = new Student("李四", 18, 58);
        s[2] = new Student("王五", 20, 79);


        Arrays.sort(s, new Comparator<Student>() {
            @Override
            public int compare(St