Java

多维数组

1. 形式

   • int a[][]=new int[2][5];
   • int a[][]={{1,2},{2,3}};

2. 本质上是由一维数组进行数组的嵌套

   int[][] array={{1,2},{2,3},{3,4},{4,5}}
   /*
   1,2 array[0]
   2,3 array[1]
   3,4 array[2]
   4,5 array[3]
   */

Arrays类

1. java.util.Arrays

2. Arrays类中的方法都是static修饰的静态方法，在使用的时候直接使用类名调用，不能使用对象名来调用

3. 常用方法

   • 给数组赋值：fil
   • 数组排序：sort（升序）
   • 比较元素是否相等：equals
   • 查找元素：binarySearch二分查找法
   • 打印数组：toString
   • 根据指定内容返回哈希码：hashCode

4. 点进Arrays类点击左下方structure可以查看所有方法

   int[] a={1,2,56,88,34,564,32};

   System.out.println(a);//打印出数组对象对应的哈希值
   System.out.println(Arrays.toString(a));//遍历数组并打印
   Arrays.sort(a);//升序排序
   Arrays.fill(a,2,4,0);//用0填充数组a2到4之间的所有元素

冒泡排序

//时间复杂度为O(n^2)
//优化后的冒泡排序
public static int[] bubbleSort(int[] array){
        int temp=0;
        for(int i=0;i<array.length-1;i++){
                boolean flag=false;//通过flag标识减少没有意义的比较
                for(int j=0;j<array.length-1-i;j++){
                        if(array[j]>array[j+1]){
                                temp=array[j];
                                array[j]=array[j+1];
                                array[j+1]=temp;
                                flag=true;
                        }
                }
                if（flag==false） break;
        }
        return array;
}

稀疏数组

1. 稀疏数组是一种由压缩算法产生的数据结构，是一个二维数组

2. 当一个数组中大部分元素为0，或者同一值，可以使用稀疏数组来保存该数组

3. 稀疏数组的处理方式

   • 记录数组一共几行几列，存在多少个不同的值
   • 把具有不同值的元素和行列及值记录在一个小数组中从而缩小程序规模

4. 只记录有效值的行、列、值

   //创建二维数组11*11 0：没棋子 1：黑棋 2：白棋
   int[][] array1=new int[11][11];
   array[1][2]=1;
   array[2][3]=2;
   //输出原始的数组
   System.out.println("输出原始的数组:");
   for(int[] ints:array1){
   for(int anInt:ints){
   System.out.print(anInt+"\t");
   }
   System.out.println()；
   }
   //转换为稀疏数组
   //1.获取有效值的个数
   int sum=0;
   for(int i=0;i<11;i++){
   for(int j=0;j<11;j++){
   if(array[i][j]!=0) sum++;
   }

   }
   //2.创建一个稀疏数组
   int[][] array2=new int[sum+1][3];
   //sum+1为存放多少个有效值所需要数组长度，3为行、列、值

   array2[0][0]=11;//多少行
   array2[0][1]=11;//多少列
   array2[0][2]=sum;//多少个有效值

   //遍历二维数组，将非零的值存放在稀疏数组中
   int count=0;
   for(int i=0;i<array1.length;i++){

       for(int j=0;j<array1[i].length;j++){
               if(array1[i][j]!=0){
                       count++;
                       array2[count][0]=i;//第一行存横坐标
                       array2[count][1]=j;//第二行存纵坐标
                       array2[count][2]=[i][j];//存有效值
               }
       }
       for（int i=0;i<array2.length;i++）{
               System.out.println(array[i][0]+"\t"+arrar2[i][1]+"\t"+arrar2[i][2]+"\t");
       }

   }
   //稀疏数组还原原本数组
   //1.读取稀疏数组
   int[][] array3=new int[array2[0][0]][array2[0][1]];
   //2.给其中的元素还原其值
   for(int i=1;i<array2.length;i++){//第行头部信息不用读取
   array3[array2[i][0]][array2[i][1]]=array2[i][2];//横纵坐标还原
   }
   //3.打印
   for(int[] ints:array3){
   for(int anInt:ints){
   System.out.print(anInt+"\t");
   }
   System.out.println()；
   }

什么是面向对象

1. Java的核心思想就是OOP面向对象编程
2. 类=属性+方法
3. 面向过程是线性思维，面向对象是分类思维方式
4. 面向对象和面向过程不可分割
5. 面向对象编程的本质：以类的方式组织代码，以对象的方式组织和封装数据
6. 三大特征：封装、继承、多态
7. 类是一个模板，是抽象的
8. 对象是一个具体的实例，是具象的
9. 对象是通过引用来进行操作的 栈——>堆（地址）
10. 属性：字段field 成员变量，默认初始化 char：u0000
11. 类：静态的属性、动态的方法

方法进阶

1. 修饰符 返回值类型 方法名（…）{ 方法体 return 返回值; }

2. break和return的区别

   • break跳出switch、结束整个循环
   • return代表方法结束，返回一个结果

3. 方法命名原则：见名知意+驼峰原则

4. 参数列表：可变长参数

5. IO流读文件一定会抛出异常public void readFile (String file) throws IOException

6. 方法分为静态方法和非静态方法

   • 静态方法可以通过 类名.方法名 直接调用
   • 非静态方法只有先实例化再 对象名.方法名 调用
   • 同类型方法可以互相调用
   • static修饰的方法类创建则存在，否则类实例化后才存在

7. 实际参数和形式参数类型必须一一对应

8. Java都是值传递，引用传递时传递对象，本质也是值传递

   int a=1;
   public static void change(int a){ a=10 ;}//a的值不会改变，因为这个a时形参，与实际a无关
   public static void change(Person person){ Person.name="wch"; };
   //person是一个对象：指向的时一个具体的person，可以改变属性，本质还是值传递

类与对象的创建

1. 类是抽象的数据类型，是一类事物的整体描述
2. 对象是抽象概念的具体实例
3. 使用new关键字创建对象
4. 创建时除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
5. 类中的构造器也称为构造方法，是在创建对象时必须要调用的
   • 必须和类名相同
   • 必须没有返回值类型，也不能用void修饰
6. 一个项目中各个类中不应该有main方法，应该另起一个class文件写main方法
7. this代表当前的类
8. 面向对象编程的本质就是以类的方式组织代码，以对象的方式封装数据

构造器

1. 类中与类名相同且没有返回值的public修饰的方法
2. 一个类即使什么也不写，也会存在默认构造方法
3. 作用
   • 实例化一些初始值，用来初始化值
   • 使用new关键字，本质是在调用构造器
   • 一旦定义了有参构造器，无参就必须显式定义
4. Alt+Insert 生成构造器的快捷键

创建对象内存分析

1. 方法区存放类及其属性、方法、常量池，main方法压入栈底层
2. 创建对象时，创建的对象名压入栈中，堆中分配一块内存进行存储（未赋值）
3. 赋值后，方法区中的常量池将值赋给堆中的变量

封装

1. 高内聚、低耦合

   • 高内聚就是类的内部数据操作细节自己完成，不许干涉
   • 低耦合就是仅暴露少量的方法给外部使用

2. 应禁止直接访问一个对象的数据的实际表示，而是应该通过操作接口来访问，称为信息隐藏

3. 属性私有，get/set

4. private关键字修饰属性，提供一些可以操作这些属性的get/set方法

5. 封装的意义

   • 提高程序安全性、保护数据
   • 隐藏代码的实现细节
   • 统一接口，形成规范
   • 提高系统的可维护性

继承

1. extends关键字
2. 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
3. Java类中只有单继承，没有多继承
4. 继承的关系是is的关系（学生继承Person，学生 is Person）
5. 类与类之间的关系
   • 继承
   • 依赖
   • 聚合
   • 组合
   • ···
6. 子类继承父类的所有public修饰的方法和属性
7. protected、default、public、private
8. 快捷键 Ctrl+H 打开继承树
9. Object类是所有类的父类，继承其所有的方法，在java.lang包中

super关键字

1. super代表父类，this代表当前
2. 子类创建时构造器会默认调用父类的构造器，隐藏了代码：super（）且必须为第一行
3. 注意：
   • super调用父类的构造方法且必须在第一行
   • super必须只能出现在子类的方法或构造方法中
   • 不能和this同时调用构造方法
   • this没有继承也可以使用，super只能在继承条件下使用
   • this本身调用者这个对象，super代表父类对象的应用
4. Ctrl+F 搜索

方法的重写

1. 重写都是方法的重写，与属性无关

2. 重写只对非静态的、public修饰的方法有效

3. 父类的引用指向了子类

4. 静态方法的调用只与左边的定义的数据类型有关

5. 注解：有功能的注释

6. 重写的特点

   • 需要有继承关系，子类重写父类的方法
   • 方法名和参数列表必须相同
   • 修饰符：范围可以扩大，但不能缩小private——>protected——>default——>public
   • 抛出的异常：范围可以缩小但不能扩大ClassNotFoundException——>Exception(大)
   • 只有方法体不同

7. 重写的意义

   • 父类的功能子类不一定需要或满足

   A extends B;

   A a = new A();
   a.test();

   B b = new A();
   b.test();

多态

1. 动态编译，类型具有可拓展性

2. 同一方法可以根据发送对象的不同而采取多种不同的行为方式

3. 一个对象的实际类型是确定的，但可以指向对象的引用类型有很多

4. 多态存在的条件

   • 有继承关系存在
   • 子类重写父类的方法
   • 父类引用指向子类的对象

5. 多态指的是方法的多态，属性没有多态性

6. 子类重写了父类的方法，就执行子类重写后的方法

7. 对象执行的方法首先看左边对象的类型

8. 父类和子类之间有联系，可以强制转换

9. 类型转换异常：ClassCastException

10. Father f1=new Son（）；

11. static、final、private修饰的方法不能重写

    Students extends Person;

    Students s1=new Student();
    Person s2=new Student();
    //父类的引用指向子类，不能调用子类独有的方法，除非是子类中重写的父类方法
    Object s3=new Student();
    //对象执行的方法首先看左边对象的类型

instanceof和类型转换

1. 前提：父类的引用指向子类的对象

2. 作用：判断一个对象是什么类型

3. System.out.println(X instanceof Y);取决于X和Y是否存在父子关系

4. 类型之间的转换

   • Person s1=new Student();
   • 高（父）——>低（子） 强制转换
   • Student s2=（Student）s1；
   • （（Student）s1）.go；
   • Person person=s1；低（子）——>高（父） 自然转换，子类转父类可能会丢失一些方法

   Object object=new Student();

   System.out.println(object instanceof Student);//√
   System.out.println(object instanceof Person);//√
   System.out.println(object instanceof Object);//√
   System.out.println(object instanceof Teacher);//×
   System.out.println(object instanceof String);//×

static关键字

1. static修饰的变量称为静态变量又叫做类变量

2. 静态变量在内存中只有一个

3. 非静态方法要实例化之后才可以调用，静态方法可以直接 类名.方法名 调用

4. 执行顺序：静态代码块、匿名代码块、构造方法

5. 静态导入包后可以直接使用包中的方法（random、PI）

   import static java.lang.Math.random；

   import static java.lang.Math.PI；

6. final修饰的类断子绝孙不能被继承

   public void run(){}
   public static void go(){}

   new Student().run;
   Student.go;

抽象类

1. abstract修饰符

   • 修饰方法则为抽象方法
   • 修饰类则为抽象类

2. 只有方法名字，其他没有

3. 抽象类的所有方法必须要由继承的子类重写来实现方法

4. 局限性：extends的单继承

5. 抽象类的特点

   • 不能new抽象类的对象
   • 抽象类不能实例化，只能靠子类去实现
   • 抽象方法必须存在抽象类中
   • 抽象类中可以写普通方法
   • 抽象类不能实例化但也存在构造器

6. 抽象类可以提高开发效率，可扩展性提高

   public abstract class Action{

       public static void say（）{System.out.println("hello")};
       public abstract void daSomething();//不需要写方法体

   }

接口的定义与实现

1. 接口只有规范（抽象方法），自己不能写方法

2. 接口的本质是契约，是面向对象的精髓所在

3. 声明类的关键字是class，声明接口的关键字是interface

4. 接口中的方法默认为public abstract修饰的抽象方法

5. 接口中的变量默认为public static final修饰的常量

6. implements继承接口，可以实现 伪多继承

   public interface UserService{
   //自动隐藏了
   void add(String name);
   void delete(String name);
   void update(String name);
   void query(String name);

   }
   //多继承
   public class UserServiceImpl implements UserService，TimeService
   {
   //必须重写接口的所有方法
   @override
   void add(String name);
   void delete(String name);
   void update(String name);
   void query(String name);

   }

内部类

1. 在一个类的内部再定义一个类

2. 分类

   • 成员内部类
   • 静态内部类
   • 局部（方法）内部类
   • 匿名内部类

3. 通过这个外部类来实例化内部类

4. 内部类可以获取外部类的私有属性、方法

5. 一个java类中可以有多个class，但只能有一个public

   public class outer{

       private int id;
       public void out(){"这是外部类的方法"};
   public void out(){
   
           class inner{  }//局部内部类
   
   };
   
   public class Inner{
   
           public void in(){"这是内部类的方法"};
   
   }
   public void getID(){System.out.println(id)};</code></pre>
   }
   
   //通过这个外部类来实例化内部类
   
   Outer outer = new Outer();
   
   Outer.Inner inner = outer.new Inner();
   class Apple{
       public void eat(){}
   }
   
   new Apple().eat();//匿名内部类