0基础学JAVA（第六天）

1.List集合

list容器（集合）   

之前学过的集合是数组，但是数组只能存储一种类型的数据，而且一旦声明长度之后不能更改，只能建立一个新的数组，所以为了解决这个弊端建立了list

list    接口          有三个实现类：ArrayList       LinkList    Vector

1.添加元素     add

添加的数据如果不加"",例如直接添加12，那么存入的类型就是int类型

        list.add("a");
        list.add(12+13);
        list.add(null);
        list.add(33.33);
        System.out.println(list);      //[a, 25, null, 33.33]

2.获取元素     get

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

3.在指定位置插入元素     add

        list.add(1,44);               //在1位置添加44，原本1位置和后边数据往后移
        System.out.println(list);     //[a, 44, 25, null, 33.33]
        list.add(5,54);               //上面的list长度是5所以最大只能在5的位置插入数
       //list.add(9,54);              下标越界
        System.out.println(list);     //[a, 44, 25, null, 33.33, 54]

4.设定元素     set

list.set(2,22);
System.out.println(list);
//原本2位置的数换成了22，其他位置的数不变[a, 44, 22, null, 33.33, 54]

5.包含元素     contains/containsAll

boolean b=list.contains(22);
System.out.println(b);            //true
b=list.indexOf(22)!=-1;
System.out.println(b);            //true


List list1=new ArrayList();
list1.add(33.33);
list1.add(null);
b=list.containsAll(list1);       //判断是否包含另一个集合中所有元素
System.out.println(b+"------");  //true

6.将list1数组中的数全部添加到list中      addAll

System.out.println(list);   //[a, 44, 22, null, 33.33, 54]
System.out.println(list1);  //[33.33, null]
list.addAll(list1);
System.out.println(list);   //[a, 44, 22, null, 33.33, 54, 33.33, null]

7.删除元素     remove

参数传对象，删除这个对象，返回boolean

参数传下标 删除这个下标的对象 返回这个对象

obj=list.remove(null);
System.out.println(obj);  //true
System.out.println(list);//[a, 44, 22, 33.33, 54, 33.33, null],只会删除第一个符合的元素

8.删除下标     remove

System.out.println(list);          //[a, 44, 22, 33.33, 54, 33.33, null]
obj=list.remove(2);
System.out.println(list);          //[a, 44, 33.33, 54, 33.33, null]
System.out.println(obj+"=====");   //删除下标为2的位置的数据返回被删除的数据：22

9.长度     length

长度方法一般用在循环

 for (int i=0;i<list.size();i++){
 System.out.println(list.get(i));
}
//结果：
//            a
//            33.33
//            54
//            33.33
//            null
     

另一种循环遍历方式

此外循环遍历数组还可以用下面的方法

for (Object item:list){
                System.out.println(item);

            }

 两个方法输出结果一致

10.下标     index

 b=list.indexOf(22)!=-1;
System.out.println(list);              //[a, 44, 22, null, 33.33, 54]
System.out.println(b+"------");        //true
System.out.println(list.indexOf(22));  //输出的是下标2

11.ArrayList和LinkedList

ArrayList的默认容量是10，如果容量不够会自动扩容每次扩容都是向右移位+原容量

所以第一次扩容之后是15，第二次扩容之后是22

1.LinkedList和Arraylist用法一样，但是存储数据的接口不一样

2.LinkedList 是以链表的方式

3.最大值和ArrayList一样

12.迭代器

 //迭代器
Iterator is=list.iterator();//获取了一个迭代器  迭代器只能知道下一个元素是谁，有没有下一个元素
       //适合不知道有多少个元素的时候
while (is.hasNext()){//hasNext()判断是否有下一个1
  System.out.println(is.next());
        }

2.代码块

1.代码块

1.成员代码块：

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

{
        //成员代码块      每一次new对象的时候执行,而且在构造方法之前运行
        System.out.println("父类---成员代码块");
 }

2.静态代码块

静态代码块： 一个类的静态代码块在程序运行期间只会执行一次（在加载类对象的时候执行），比成员代码块执行还要早

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

    }

public class EasyBlock {
    {
        //成员代码块      每一次new对象的时候执行,而且在构造方法之前运行
        System.out.println("父类---成员代码块");
    }
    EasyBlock(){
        System.out.println("父类---构造方法");
    }
    EasyBlock(int a){
        System.out.println("父类---构造方法");
    }
    public static void main(String[] args) {
        new EasyBlock2();
        //先是父类的静态代码块，然后是子类的静态代码快，父类成员代码块，父类构造方法，子类成员代码块，子类构造方法
    }
    //静态代码块    一个类的静态代码块在程序运行期间只会执行一次（在加载类对象的时候执行），比成员代码块执行还要早
    //如果父类和子类同时执行静态代码块的时候，先执行父类的
    static {
        System.out.println("父类---静态代码块");

    }
}

class EasyBlock2 extends EasyBlock {
    {
        //成员代码块      每一次new对象的时候执行,而且在构造方法之前运行
        System.out.println("子类----成员代码块");
    }
    EasyBlock2(){
        System.out.println("子类----构造方法");
    }
    EasyBlock2(int a){
        System.out.println("子类----参数构造方法");
    }

    //如果父类和子类同时执行静态代码块的时候，先执行父类的
    static {
        System.out.println("子类---静态代码块");
    }
}

结果：

父类---静态代码块
子类---静态代码块
父类---成员代码块
父类---构造方法
子类----成员代码块
子类----构造方法

3.内部类

1.成员内部类

需要对象来调用      用的比较少

2.静态内部类

用static修饰，而且四个访问权限修饰符

3.匿名内部类

4.局部内部类

在方法中建一个类

public class EasyClass {
    public static void main(String[] args) {
test9();

    }
    //外部类：独立的类
    //内部类：在类内部就是内部类

    //声明类的时候只能用public  default

    //静态内部类       用的比较多
    static class InnerA {//EasyClass的内部类
        //访问权限修饰符四个都可以用
    }
    public static void test() {
        InnerA innerA = new InnerA();
    }


    //成员（对象）内部类//需要对象来调用      用的比较少
    //访问权限修饰符四个都可以用
    class InnerB {//没有static修饰

    }

    public static void test1() {
        new EasyClass().new InnerB();
    }

    //局部内部类，在方法中建一个类    用的很少
    //不能用public，private protected  只能什么也不加    使用static都不可以
    public void inner() {
        class InnerC {//语法通过，


        }
    }

    public static void test9() {
        //匿名内部类对象
   AbstractClass ac = new AbstractClass(){//现在已经有了一个对象，但不是AbstractClass类
            @Override
            public void method() {       //会重写下面的抽象类中的method方法
                System.out.println("df");
            }
        };
        System.out.println(ac.getClass());
        AbstractClass aca = new AbstractClass() {//现在已经有了一个对象，但是不是 AbstractClass类，系统会主动加载（生成一个类）
            @Override
            public void method() {
                System.out.println("df");
            }
        };
        System.out.println(aca.getClass());
        System.out.println(ac.getClass()==aca.getClass());//false
         EasyInter ei=new EasyInter() {
             @Override
             public void method() {

             }
         };
         //下面的接口代码是上面的简化
         EasyInter eia=()->{//多行代码的时候用{}    一行代码就可以直接写
             int a=12;
             System.out.println(a);
         };
         EasyInterA eA=()->12;//12就是返回值  //如果有多行代码也可以用{}
         EasyInter ee=EasyClass::fun;
         ee.method();//这个就是实现下面的fun方法
    }

    public  static void fun(){
        System.out.println("fun");
    }
}



@FunctionalInterface
interface EasyInter{
    void method();
}
interface EasyInterA{
    int method();//需要一个返回值
}

abstract class AbstractClass{
    public abstract void method();
}
class Test{
public void method(){
    EasyClass.InnerA innerA=new EasyClass.InnerA();

}
}

成员内部类总结：

内部类可以是任何的访问修饰符。
由于成员内部类看起来像是外部类的一个成员，所以可以像类的成员一样拥有多种权限修饰符。
内部类的内部不能有静态信息。
内部类也是类，该继承的继承、该重写的重写、该重载的重载，this和super随便用。
外部类访问内部类的信息，必须先实例化内部类，然后 . 访问。
内部类可以直接使用外部类的任何信息，如果属性或者方法发生冲突（重名），使用Outer.this.成员
其他类访问内部类：
成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在外部类的对象。

静态内部类总结：

静态内部类可以包含任意的信息，可以被任意访问权限修饰符修饰。
静态内部类的方法只能访问外部类的static关联的成员。
静态内部类可以独立存在，不依赖于其他外围类。
其他类访问内部类的静态信息，直接 Outer.Inner.static成员信息 就可以了。
其他类实例化内部类 Outer.Inner instance = new Outer.Inner();，然后 instance. 成员信息（属性、方法）即可。

局部内部类，定义在方法中，只能在方法中调用
不能用public，protected，private修饰，static也不行 
————————————————

                            版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
                        
原文链接：https://blog.csdn.net/m0_63367052/article/details/140557393