java基础

顺序结构

Java的基本结构是顺序结构，除非特别指明，否则就按照顺序一句一句执行。

语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行处理的步骤组成的，它是任何一个算法都离不开的一种基本算法结构。

选择结构

if单选择结构

if双选择结构

。。。。

switch多选择结构

多选择结构还有一个实现方式就是switch case语句

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支

switch语句中的变量类型可以是：byte、short、int或char

while循环

1. 只要布尔值表达式为true,循环就会一直执行下去

2. 我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环

3. 少部分情况需要循环一直执行，比如服务器的请求响应监听等

4. 循环条件一直为true就会照成无限循环[死循环]，我们正常的业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死奔溃

do...while循环

  1. 对于while语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件也至少执行一次；
  2. do...while循环和while循环相似，不同的是，do...while循环至少执行一次
  3. while与do..while的区别：
     - while先判断后执行。do..while是先执行后判断
     - Do...while总是保证循环体会被至少执行一次！这是他们的主要差别

For循环

1. 虽然所有循环结构都可以用while或者do...while表示，但java提供了另一种语句（for循环，使一些循环结构变得更加简单）

2. for循环语句支持迭代的一种通用结构，是最有效，最灵活的循环结构

3. for循环执行的次数是执行前确定的

   • 练习计算0到100之间的奇数和偶数的和

     public class ForDemo01 {
         public static void main(String[] args) {
             //练习计算0到100之间的奇数和偶数的和
             int addsum =0;
             int elevsum =0;
             for(int i=1;i<=100;i++){
                 if(i%2==0){
                     System.out.println("这个数为偶数："+i);
                     addsum=addsum+i;
     ​
                 }else if(i%2!=0){
                     System.out.println("这个数为奇数："+i);
                     elevsum =elevsum+i;
     ​
                 }
                 System.out.println("偶数和："+elevsum);
                 System.out.println("奇数和："+addsum);
             }
     ​
         }
     }

   • 用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个

public class ForDemo02 {
    public static void main(String[] args) {
        //用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个
​
        for(int i=1;i<=1000;i++){
            if(i%5==0){
                System.out.print(i+"\t");
            }
            if(i%(5*3)==0){
                System.out.println();
            }
      
     }
    }
}

• 打印九九乘法表

public class JiuJiuDemo01 {
    public static void main(String[] args) {
        //打印九九乘法表
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(i+"*"+j+"="+(i*j)+"\t");
            }
            System.out.println();
        }
    }
}

什么是方法

System.out.println()在我们认为中就是一个输出语句，其实System就是一个类，out就是System类中的标准输出对象out, println()就是System类中的标准输出对象out中的方法；

1. java方法是语句集合，它们在一起执行一个功能。

   • 方法是解决一类问题的步骤的有序组合

   • 方法包含类或对象

   • 方法在程序中被创建，在其他地方被引用

2. 设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合，我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能，这样利于我们后期的扩展。

方法的定义

Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法

1. 方法包含一个方法头和一个方法体

   • 修饰符：修饰符，这是可选的，告诉编译器如何调用该方法，定义了该方法的方法类型

   • 返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型，有些方法执行所需的操作，但没有返回值，这种情况下，returnValueType是关键字void.

   • 方法名：是方法的实际名称。方法名和参数表共同构成的方法签名

   • 参数类型：参数是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型，顺序和参数的个数。参数是可选的，方法可以不包含任何参数

     • 形式参数：在方法被调用时用于接收外界输入的数据

     • 形式参数：调用方法实际传给方法的数据

   • 方法体：方法体包含具体的语句，定义该方法的功能

方法调用

调用方法：对象名.方法名（实参列表）

Java支持两种调用方法的方式，根据方法是返回值来选择

当方法返回一个值的时候，方法调用通常被当做一个值。

方法的重载

重载就是在一个类中，有相同的函数名称，但是形参不同的函数

方法重载的规则：

• 方法名称必须相同

• 参数列表必须不同（个数不同、或者类型不同、参数排列顺序不同等）

• 方法的返回类型可以相同也可以不相同

• 仅仅返回类型不同不足以成为方法的重载

可变参数

1. jDK1.5 开始，Java支持传递同类型的可变参数给一个方法

2. 在方法声明中，在指定参数类型后加一个省略号（...）

3. 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

递归调用

1. 递归就是：A方法调用A方法！就是自己调用自己

2. 利用递归调用可以解决一些简单的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需要少量的程序就可以描述出解题过程需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。（大的不建议使用递归）

   public class Demo05 {
       public static void main(String[] args) {
   ​
           System.out.println(f(5));
       }
       public static int f(int n){
           if(n==1){
               return 1;
           }else{
               return n*f(n-1);
           }
       }
   }

3. 递归结构包括两部分：

   • 递归头：什么时候不调用自身的方法。如果没有头，就陷入死循环。

   • 递归体：什么时候需要调用自身的方法

数组

1. 数组是相同类型的有序集合

2. 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成

3. 其中，每一个数组称作一个数组元素，每个数组元素可以通过一个下标来访问它们

4. 所有数组都是从0开始

三种初始化

1. 静态初始化

2. 动态初始化

3. 数组默认初始化

   • 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的元素也被按照实例变量同样的方式被隐式初始化

数组的四个基本特点

1. 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的

2. 其元素必须是相同类型，不允许出现混合类型

3. 数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型

4. 数组变量属于引用数据类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的

数组边界

1. 下标的合法区间：[0,length-1]，如果越界就会报错

2. ArrayIndexOutOfBoundsException：数组下标异常

Arrays类

1. 数组的工具类java.util.Arrays

2. 由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据进行一些基本的操作。

3. 查看JDK帮助文档（就是API文档）

4. Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意：是”不用“而不是”不能“）

5. 具体以下常用功能

   • 给数组赋值：通过fill方法

   • 对数组排序：通过sort方法，按升序

   • 比较数组：通过equals方法比较数组中元素值是否等

   • 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找操作

     import java.util.Arrays;
     ​
     public class ArraysDemo107 {
         public static void main(String[] args) {
     ​
             int[] a={1,2,3,222,3,44,456};
             int[] sort =sort(a);//调用完成我们自己写的排序方法以后，返回一个排序后的数组
             System.out.println(Arrays.toString(sort));
         }
         //冒泡排序
         //1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换它们的位置
         //2.每一次比较，都会产生出一个最大，或者最小的数字
         //3.下一轮则可以少一次排序
         //4.一次循环，直到结束；
         public static int[] sort(int[] array){
             //临时变量temp
             int temp =0;
             //外层循环，判断我们这个要走多少次
             for(int i=0;iarray[j]){
                         temp=array[j];
                         array[j]=array[j+1];
                         array[j+1]=temp;
                         flag=true;
                     }
                 }
                 if(flag==false){
                     break;
                 }
             }
             return array;
         }
     }

稀疏数组的介绍

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

2. 稀疏数组的处理方式：

   • 记录数组一共有几行几列，有多少不同值

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

public class ArraysXiDemo06 {
    public static void main(String[] args) {
        //1.创建一个二维数组 11*11    0:没有棋子，，1：黑棋   2：白棋
        int[][] arrays =new int[11][11];
        arrays[1][2]=1;
        arrays[2][3]=2;
        //输出原始数组
        System.out.println("输出原始数组：");
        for(int[] ints : arrays){
            for(int anInt : ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("======================");
        //转换为稀疏数组保存
        //获取有效值
        int sum=0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(arrays[i][j]!=0) {
                    sum++;
                }
            }
        }
        System.out.println("有效值："+sum);
​
        //创建稀疏数组
        int[][] arrays1=new int[sum+1][3];
        arrays1[0][0]=11;
        arrays1[0][1]=11;
        arrays1[0][2]=sum;
​
        //遍历二维数组，将非零的值，存放到稀疏数组中
        int count=0;
        for(int i=0;i

面向过程&面向对象

面向过程思想：

1. 步骤清晰简单，第一步做什么，第二步做什么

2. 面向过程适合处理一些比较为简单的问题

面向对象思想：

1. 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索

2. 面向对象适合处理复杂问题，适合处理需要多人协作的问题

对于描述复杂的事务，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

1. 面向对象编程

2. 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。

3. 抽象

4. 三大特性：

   • 封装

   • 继承

   • 多态

5. 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类是抽象的，是对对象的抽象

6. 从代码运行角度考虑是先有类后有代码。类是对象的模板

类与对象的关系

1. 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。

   • 动物、植物、手机、电脑.......

   • Person类，Pet类，Car类等，这些类都是用来描述/定义某一具体的事物应该具备的特点与行为

2. 对象是抽象概念的具体实例

   • 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例

   • 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念

创建与初始化对象

1. 使用new 关键字创建对象

2. 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用

3. 类中的构造器也称构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：

   • 必须和类的名字相同

   • 必须没有返回类型，也不能写void

4. 构造器作用：

   • new本质在调用构造方法

   • 初始化对象的值

5. 构造器注意点：

   • 定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造

   • 快捷键：Alt+Insert

   • this.什么：就是当前的

总结1

1. 类与对象：类是一个模板，对象是一个具体的实例

2. 方法：定义、调用

3. 对应的引用：引用数据类型、基本类型，对象是通过引用来操作的 栈--->堆

4. 属性：字段Field 成员变量

   • 默认方法：

     • 数字：0 0.0

     • char:u000

     • boolean: false

     • 引用：null

     • 修饰符 属性类型 属性名=属性值

5. 对象的创建与使用

   • 必须使用new 关键字创造对象，构造器 Person www =new Person();

   • 对象的属性www.name

   • 对象的方法：www.sleep()

6. 类：

   • 静态属性：属性

   • 动态的行为：方法

7. 封装、继承、多态

封装

1. 该漏的漏，该藏的藏

   • 我们程序设计要求“高内聚、低耦合”。高内聚就是类的内部数据操作细节自己完成， 不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

2. 封装(数据的隐藏）

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

3. 作用：

   • 提高程序的安全性，保护数据

   • 隐藏代码的实现细节

   • 统一接口

   • 系统可维护增加

继承

1. 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模

2. extends的意思是“扩展”。子类是父类的扩展

3. JAVA中类只有单继承，没有多继承

4. 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

5. 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示

6. 子类和父类之间，从意义上讲应该具有“is a”的关系

7. object类

8. super

9. 方法重写

super注意点

1. super调用父亲的构造方法，必须在构造方法的第一个

2. super必须只能出现在子类的方法或者构造方法中

3. super和this 不能同时调用构造方法

• 代表的对象不同

  • this: 本身调用者这个对象

  • super: 代表父类对象的应用

• 前提

  • this: 没有唯一也可以使用

  • super: 只能在继承条件下可以使用

• 构造方法

  • this();本身的构造

  • super();父类的构造

重写

重写：需要有继承关系，子类重写父类的方法！

1. 方法名必须相同

2. 参数列表必须相同

3. 修饰符：范围可以扩大 public > protected > Default >private

4. 抛出异常：范围可以被缩小，但是不能扩大：ClassNotFoundException --->Exception(大的异常)

5. 重写，子类的方法和父类的方法必须相同，方法体不同

为什么需要重写：

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

• 重写的快捷键：Alt+Imsert ： override;

多态

注意事项：

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

2. 父类和子类，有联系 类型 转换异常！ ClassCastException!

3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象

public class Prson {
    public void run(){
        System.out.println("run");
    }

public class Student extends Prson {
    public  void run(){
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}

public class Application {
    public static void main(String[] args) {
​
        //可以指向的引用类型就不确定了：父类的引用指向子类
​
        //Student 能调用的方法都是自己的或者是继承父类的
        Student s1= new Student();
        //Prson是父类型，但是不能调用子类独有的方法
        Prson s2 = new Student();
        Object s3 = new Student();
​
        //对象能执行哪些方法，主要看左边的类型，和右边关系不大
        s2.run();//子类重写了父类的方法，执行子类的方法
        s1.run();
    }
}

• static 方法，属于类，它不属于实例

• final 常量

• private 方法

多态：

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

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

3. 多态存在条件

   • 有继承关系

   • 子类重写父类方法

   • 父类引用指向子类对象

4. 注意:多态是方法的多态，属性没有多态性

5. instanceof（类型转换）引用类型，判断一个对象是什么类型

   • object > String

static

输出的先后顺序是：静态代码块 >匿名代码 > 构造方法

抽象类

1. abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象的。

2. 抽象类中可以没有抽象方法，但是抽象方法类一定要有声明的抽象类

3. 抽象类，不能使用new关键字来创建对象，它是用来让子类继承的。

4. 抽象方法，只有方法的的声明，没有方法的实现，它是用来让子类实现的

5. 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

接口

1. 普通类：只有具体实现

2. 抽象类：具体实现和规范（抽象方法）都有

3. 接口：只有规范

4. 接口就是规范，定义的是一组规划，体现了现实世界中“如果你是...则必须....”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你是好人，则必须干掉坏人，则必须欺负好人。

5. 接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵循

6. oo精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如：C++、Java、C#等），就是因为设计模式的研究，实际上就是如何合理的去抽象

内部类

内部类就是在一个类的内部在定义一个类，比如，A类定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就称为外部类

1. 成员内部类

2. 静态内部类

3. 局部内部类

4. 匿名内部类

什么是异常

1. 实际工作中，遇到的情况不可能是非常完美的。比如：你写的某个模块，用户输入不一定符合你的要求、你的程序要打开某个文件，这个文件可能不存在或者格式不对，你要读取数据库的数据，数据可能是空的。我们的程序再跑着，内存或硬件可能满了。等等。

2. 软件程序过程中，非常可能遇到刚刚提到的这些异常问题。我们叫异常，英文：Exception,意思是例外。这些，例外情况，或者叫异常，怎么让我们写的程序做出合理的处理。而不至于程序崩溃

3. 异常指程序运行中出现的不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等。

4. 异常发生在程序运行期间，他影响了正常的程序执行流程。

简单分类

1. 要理解java异常处理是如何工作的，你需要掌握以下三种类型的异常：

   • 检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在的文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略

   • 运行时异常：运行时异常是可能被程序员避免地异常。与检查性异常相反,运行时异常可以在编译时被忽略

   • 错误：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

异常体系结构

1. java把异常当做对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。

2. 在java API 中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception.

Error

1. Error类对象由Java虚拟机生成抛出，大多数错误与代码编写者所执行的操作无关

2. Java虚拟机运行错误（Virtual MachineError）,JVM不再有继续执行操作所需要的内存资源时，将出现OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止

3. 还有发生在虚拟机试图执行应用时，如类定义错误（NoClassDefFoundError）、链接错误（LinkageError）。这些错误是不可查的，因为它们在应用程序的控制下和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。

Exception

1. 在Exception分支中有一个重要的子类RuntimeException(运行时异常)

   • ArrayIndexOutOfBoundsException(数组下标越界异常)

   • NullPointerException(空指针异常)

   • ArithmeticException(算数异常)

   • MissingResourceException(丢失资源)

   • ClassNotFountException(找不到类)等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理

2. 这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生

3. Error和Exception的区别：Error通常是灾难性的致命错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常

异常处理机制

1. 抛出异常

2. 捕获异常(Ctrl+Alt+t)

3. 异常五个关键字：try、catch、finally、throw、throws

自己定义异常

1. 使用Java内置异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需要继承Exception类即可

2. 在程序中使用自定义异常类，大体可分为以下几个步骤：

   • 创建自定义异常

   • 在方法中通过throw关键字抛出异常对象

   • 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步骤。

   • 在抛出异常方法的调用者中捕获并处理异常

实际应用中的经验总结

1. 处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理

2. 在多重catch块后面，可以加一个catch(Exception)来处理可能会被遗漏的异常

3. 对于不确定的代码，也可以加上try-catch，处理潜在的异常

4. 尽量去处理异常，切忌只是简单地调用 printStackTrace()去打印输出

5. 具体如何处理异常，要根据不同的业务需求和异常类型去决定

6. 尽量添加finally语句块去释放占用的资源