7-19学习笔记

一、代码块

1、成员代码块

            每一次new对象时执行
        成员代码块在构造方法之前运行

public class EasyBlock {
    {
        System.out.println("成员代码块");
    }
}

2、静态代码块

        一个类的静态代码块只会执行一次
        只在加载类对象时执行

public class EasyBlock {
    static {
        System.out.println("静态代码块");
    }
}

 3、创建子类对象时，父类静态块、块、构造器、子类静态块、块、构造器的执行顺序

         1 父类静态代码块
         2 子类静态代码块
         3 父类的成员代码块
         4 父类的构造方法
         5 子类的成员代码块
         6 子类的构造方法

public class EasyBlock {
    static {
        //静态代码块  一个类的静态代码块只会执行一次
        //只在加载类对象时执行
        System.out.println("父类----静态代码块");
    }
    {
        //成员代码块  每一次new对象时执行
        //成员代码块在构造方法之前运行
        System.out.println("父类----成员代码块");
    }

    EasyBlock(){
        System.out.println("父类----构造方法");
    }
    EasyBlock(int num){
        System.out.println("父类----带参数构造方法");
    }

    public static void main(String[] args) {
//        new EasyBlock();
//        new EasyBlock(12);
        new EasySon();
        // 1 父类静态代码块
        // 2 子类静态代码块
        // 3 父类的成员代码块
        // 4 父类的构造方法
        // 5 子类的成员代码块
        // 6 子类的构造方法
    }
}

class EasySon extends EasyBlock {

    static {
        System.out.println("子类----静态代码块");
    }

    {
        System.out.println("子类----成员代码块");
    }
    EasySon(){
        System.out.println("子类----构造方法");
    }
    EasySon(int num){
        System.out.println("子类----带参数构造方法");
    }

}

二、内部类 

                外部类  只能用public default修饰  如：

public class EasyInnerClass {}

class Test{
    static void method(){}
}

                 内部类  即在类中定义类

当前外部类需要某些对象支持它的业务，但又不想让其它类随意访问这个类型，就可以定义成内部类

1、静态内部类

public class EasyInnerClass {

    //静态内部类
    public static class InnerA {
        //四种访问权限修饰词都可使用
    }
    //内部使用
    public static void test() {
            InnerA a = new InnerA();
    }
}
//外部使用
class Test{
    static void method(){
        EasyInnerClass.InnerA a=new EasyInnerClass.InnerA();
    }
}

2、成员内部类

public class EasyInnerClass {

    //成员（对象）内部类
    class InnerB {
        //四种访问权限修饰词都可使用
    }

    //使用
    public static void test() {
            new EasyInnerClass().new InnerB();
    }
}

 3、局部内部类

public class EasyInnerClass {

    public void inner() {
        //局部内部类  只能在该方法中调用
        class InnerC {
            //四种访问权限修饰词均不能使用
        }
        new InnerC();
    }
}

        出了该方法就没了

 4、匿名内部类

public class EasyInnerClass {
    public static void test() {
        //匿名内部类对象
        AbstractClass ac=new AbstractClass() {
            @Override
            public void method() { }
        };
        AbstractClass aca=new AbstractClass() {
            @Override
            public void method() { }
        };
        System.out.println(ac.getClass());//class com.easy7_19.EasyInnerClass$1
        System.out.println(aca.getClass());//class com.easy7_19.EasyInnerClass$2
        System.out.println(ac.getClass()==aca.getClass());//这匿名内部类对象不是一个类
    }
}
abstract class AbstractClass{
    public abstract void method();
}

4、 Lambda表达式

对于如下函数式接口

@FunctionalInterface
interface EasyInter{
    void method();
}

 采用匿名内部类的形式声明对象

public class EasyInnerClass {
    public static void test() {
        EasyInter ea=new EasyInter() {
            @Override
            public void method() {}             
        };
    }
}

@FunctionalInterface
interface EasyInter{
    void method();
}

用 Lambda表达式简化上述声明

public class EasyInnerClass {
    public static void test() {
        EasyInter eia=()->{int aa=12;
            System.out.println("----------");};
        eia=()-> System.out.println("111111111");
        EasyInterA ea=()->12;
    }
}

@FunctionalInterface
interface EasyInter{
    void method();
}

还可以用已经实现的同类方法 实现接口中的方法

public class EasyInnerClass {
    public static void test() {
        EasyInter ee=EasyInnerClass::fun;
        ee.method();
    }
    public static void fun(){
        System.out.println("function");
    }
}

@FunctionalInterface
interface EasyInter{
    void method();
}

  容器  集合

                        之前学过的容器    数组

                弊端：只能存指定数据类型   数组的长度不可改变

三、List 是一个接口

        实现类有：  ArrayList  LinkedList  Vector

        List list=new ArrayList();

1、List 中常用的方法

（1）添加元素add（Object o）

        list.add("A");
        list.add(12);
        list.add(null);
        list.add(33.33);

（2）获取元素 get(int index)

        Object obj=list.get(2);
        System.out.println(obj);

 （3）在指定位置插入元素 add(int index,Object o)

                其他元素向后移

        list.add(1,44);
        list.add(5,"B");
        //list.add(7,'a');//报错 下标越界
        System.out.println(list);

（4）设置修改指定位置元素 set(int index,Object o)

        list.set(2,22);
        System.out.println(list);

（5）是否包含某一对象 contains(Object o)  是否包含另外一个集合中的所有元素 containsAll(Object o)

        //是否包含某一对象
        boolean bool=list.contains(22);
        System.out.println(bool);//true
        bool=list.indexOf(22)!=-1;
        System.out.println(bool);//true
        //判断是否包含另外一个集合中的所有元素
        List listA=new ArrayList();
        listA.add(33.33);
        listA.add(null);
        listA.add(2);
        bool=list.containsAll(listA);
        System.out.println(bool);//false

(6)把传入列表中的元素全部加入列表 addAll(Object o)

        //把传入列表中的元素全部加入列表
        list.addAll(listA);
        System.out.println(list);
        System.out.println("------------");
        //把传入列表加入列表
        list.add(listA);
        System.out.println(list);

(7)删除元素 删除掉找到的第一个元素  remove(int index)    remove(Object o)

        参数传对象 删除这个对象  返回  boolean
        参数传下标  删除下标位置对象  返回  被删除的对象

        list.remove("A");
        System.out.println(list);
        list.remove(2);
        System.out.println(list);
        //
        list.remove((Integer)22);//就近原则 整数默认下标
        System.out.println(list);

2、 ArrayList   扩容方式

        初始容量  10  最大容量Integer.MAX_VALUE
        扩容  1.5倍

        LinkedList  链表   最大值 Integer.MAX_VALUE

3、ArrayList LinkedList 性能比较

        ArrayList  是通过数组存储数据的  查找数据非常快
        LinkedList   是链表存储  查找速度慢  通过双向检索优化检索速度

        ArrayList  插入和删除慢  需将后面的元素前/后移
        LinkedList   插入和删除快  只需重新设置指向

超大数据量时  性能近乎相同

补：

        hash协定：若两个变量指向的对象equals是相等的，hashCode得到的数值也就相等