二维数组以及初步类部内

二维数组以及初步类部内

一, 二维数组

二维数组

​ 数组中嵌套数组

声明:

​ 数据类型[] [] 数组名;

初始化:

​ 动态初始化:先创建数组,后赋值

​ 数据类型[] [] 数组名=new

​ 数据类型[外层的长度] [内层的长度];

​ 内层二维的长度:

​ 规定了外层一维数组中每一个格子中的小数组的长度

​ 静态初始化:创建数组的同时赋值

操作二维数组中的数据:

​ 根据索引

​ 数组索引

​ 数组名[外层索引] [ 内层的索引]

public class Class_Arra {
    public static void main(String[] args) {
        int[][]arr=new int [2][];//动态  
        // 为二维数组arr索引为0位置赋值一个一维数组
        //一维数组动态初始化
       arr [0]=new int[2];
        arr[0][0]=1;
        arr[0][1]=2;


        arr[1]=new int[]{2,3,5};//静态初始化

        char [][]arr2=new char[][]{{'1','4','5'},{'5','3','5'}};//静态初始化

    }
}

二,二维数组遍历

​ 双重循环嵌套

​ 普通嵌套增强

​ 普通嵌套普通

​ 增强嵌套普通

​ 增强嵌套增强

ublic class LoopNesting {
    public static void main(String[] args) {
        int[][]arr=new int[][]{{1,6,7,4,7},{6,5,8},{7,9,0}};//for嵌套for
        for (int i = 0; i <arr.length ; i++) {
            for (int j = 0; j <arr[i].length ; j++) {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }

    }

三.Arrays 操作

package ClasssArr;

import java.util.Arrays;

public class ArraystTo {
    public static void main(String[] args) {
        int[] arr = new int[]{9, 6, 8, 5, 5, 4, 3, 2, 0};
        int[] arr0 = new int[]{9, 6, 8, 5, 5, 7, 5, 7};
        double[][] arr1 = new double[][]{{2, 5, 6,}, {3, 4}, {0}};
        double[][] arr2 = new double[][]{{2, 5, 6,}, {3, 4}, {0}};
        System.out.println(Arrays.toString(arr));//返回指定数组内容的字符串表现形式
        System.out.println(Arrays.deepToString(arr1));//返回指定数组的"深层内容"以字符串形式表示
        System.out.println(Arrays.equals(arr, arr0));//比较两个同类型数组
        System.out.println(Arrays.deepEquals(arr1, arr2));//比较两个深层数组类型
        System.out.println(Arrays.toString(Arrays.copyOf(arr, 9)));//原数据完全拷贝  新数组长度等于原数组长度
        System.out.println(Arrays.toString(Arrays.copyOf(arr, 3)));//截取   当新数组的长度<原数组长度>
        System.out.println(Arrays.toString(Arrays.copyOf(arr, 12)));//填充原数组所以位置完全拷贝,空闲位置默认值填充
        System.out.println(Arrays.toString(Arrays.copyOfRange(arr, 2, 5)));//拷贝原数组索引位置执行区间的数据,结束索引不包括
        int[] array3 = new int[8];
        System.arraycopy(arr, 1, array3, 3, 3);
        System.out.println(Arrays.toString(array3));
        Arrays.fill(arr, 1);//使用指定数填充整个数组
        System.out.println(Arrays.toString(arr));
        Arrays.fill(arr, 3, 6, 100);
        System.out.println(Arrays.toString(arr));
        Arrays.sort(arr0);//升序排序
        System.out.println(Arrays.toString(arr0));
        //二分搜索法 要求先升序排序
        System.out.println(Arrays.binarySearch(arr0,6));



    }
}

四,内部类

​ 内部类

​ 类中的定义类

​ 当类中成员也表示一个事物的时候,可以定义为内部类

​ 分类:

​ 成员内部类

​ 静态内部类

​ 私有内部类

​ 局部内部类

​ 匿名内部类

​ lanmbda表达式

​ 成员内部类:

​ 类定义在外部类的成员位置,就是成员内部类

​ 是成员,就具有成员的特点

​ 是类就具有类的特点,可以继承,可以实现…

注意:成员内部类中不能定义静态内容,除了静态的常量

​ 只有静态内部类才能定义静态内容

​ 成员内部类中可以使用外部类的成员,包括私有的

​ 成员内部类的对象通过外部类对象构建

​

public class Class001_Inner {

    //成员位置
    private int i = 1;
    static int j = 2;

    //成员内部类
    class Inner extends Object{
        //成员
        private int a = 10;
        //静态常量
        static final int B = 100;

        //成员内部类中的成员方法
        public void inner(){
            System.out.println("成员内部类中的成员方法");
            System.out.println(a);
            System.out.println(B);
            System.out.println(i);
            System.out.println(j);
        }
    }

    //外部类中的成员方法
    public void outer(){
        System.out.println("外部类中的成员方法");
        System.out.println(Inner.B);
        Inner i = new  Inner();
        System.out.println(i.a);
        i.inner();
    }
}

1,私有内部类

    私有内部类
        被private关键字修饰的成员内部类
        不能定义静态内容,除了静态的常量
        私有内部类中可以直接使用外部类的成员,包括 私有的
        在外部类中通过私有内部类的对象使用其成员,包括私有的
        私有内部类智能在所在的外部类中使用
 */
public class Class004_Inner {
    //成员
    private int i = 1;

    //私有内部类
    private class Inner{
        private int a = 10;

        private void inner(){
            System.out.println("私有内部类的成员方法");
            System.out.println(a);
            System.out.println(i);
        }
    }

    //外部类成员方法
    public void outer(){
        System.out.println("外部类成员方法");
        Inner i = new Inner();
        System.out.println(i.a);
        i.inner();
    }

2,静态内部类

​ 静态内部类
​ 静态内部类中可以定义非静态成员,可以定义静态成员
​ 静态内部类中可以使用外部类的成员,静态内容可以直接使用,成员内容需要通过外部类对象使用
​ 外部类中可以通过静态内部类类名使用其静态成员,需要通过静态内部类的对象使用内部类的成员
​ 其他类中使用静态内部类中的内容,需要根据外部类的类名找到静态内部类,根据静态内部类类名使用其静态内容,根据静态内部类对象使用其成员

public class Class005_Inner {
    //成员
    private int i = 1;
    private static int j = 2;

    //静态内部类
    static class Inner{
        //费静态成员
        int a = 10;
        //静态的
        static int b = 20;

        //非静态方法
        public void test(){
            System.out.println("非静态方法");
            System.out.println(a);
            System.out.println(b);

            System.out.println(j);
            //内部类是静态的,静态内容中可以直接使用静态内容,需要通过使用成员
            System.out.println(new Class005_Inner().i);
        }
        //静态方法
        public static void testStatic(){
            System.out.println("静态方法");
            System.out.println(b);
            System.out.println(new Inner().a);

            System.out.println(j);
            System.out.println(new Class005_Inner().i);
        }
    }

    //外部类中的成员方法
    public void outer(){
        System.out.println("外部类中的成员方法");
        //使用静态内部类中的静态内容
        System.out.println(Inner.b);
        Inner.testStatic();

        //需要通过静态内容对象使用它的成员
        Inner in = new Inner();
        System.out.println(in.a);
        in.test();
    }
}

3.局部内部类

局部内部类
不能被public,private,等,static修饰,可以被final修饰
局部内部类中可以定义成员内容,除了静态的常量,其他静态内容不可以定义
局部内部类只能在所在的方法中使用,通过对象使用成员
如果在局部内部类中使用了所在的方法中的局部变量(方法参数),这个变量要求被final修饰,在jdk1.8及之后,默认被final修饰

public class Class006_Inner {

    //方法
   public static void test(){
       //局部
       int i = 1;
       //i = 100;

       //局部内部类
       class Inner{
           int a = 1;

           //局部内部类中的成员方法
           public void test(){
               System.out.println("局部内部类中的成员方法");
               System.out.println(i);
           }
       }
       //局部内部所在的方法中使用
       Inner inner = new Inner();
       System.out.println(inner.a);
       inner.test();
   }

   public void outer(){
       //System.out.println("外部类的其他方法中使用局部内部类");
       //System.out.println(i);
   }
}