java基础复习(练习写博客)

---

Java特性和优势

---

• 简单性
• 面向对象
• 可移植性
• 高性能
• 分布式
• 动态性
• 多线程
• 安全性
• 健壮性

java三大版本

---

• JavaSE:标准版，java基础*
• JavaME:嵌入式开发
• JavaEE:企业级开发，web开发*

JDK、JRE、JVM(从前到后包含)

---

Java开发环境搭建步骤

---

• JDK下载安装
• 配置环境变量
• 网上找教程安装即可

Java程序运行机制

---

• 编译型:用编译器把整个程序.java 编译成.class（操作系统要求低）
• 解释型:实时解释程序语句（速度快）
• 程序运行机制
  

IDE

---

IDE(集成开发环境)
Java常用的IDE：Eclipse、Idea…

Java基础语法

一、注释、标识符、关键字

---

注释：

• 结构复杂需要使用
• 注释给开发人员看的
• 写注释是一个合格的开发者必备修养

Java注释的三种方式：

• 单行注释
• 多行注释
• 文档注释

public class demo1 {
    public static void main(String[] args) {
        //单行注释
        /*
        * 多
        * 行
        * 注
        * 释
        * */
        /** @Description 文档注释，写的会比较少
         *  @Author along
         *  */
        System.out.println("demo!");
    }
} 

标识符：

Java所有的组成部分都需要名字，比如类名、方法名、变量名都是标识符。
注意点：

• 标识符首字符由字母、下划线、$开始
• 变量由字母、下划线、$、数字组成
• 变量不能以数字开头，可以用中文但不必要

二、数据类型（shift双击问题）

• 强类型语言
• • 要求变量使用严格符合规定，所有变量需要先定义才能使用，安全性高。
• 弱类型语言

Java数据类型分类

public class Demo2 {
    public static void main(String[] args) {
        // 八大基本类型
        // 整数
        int t1=65536*32767;
        byte t2=127;
        short t3=32767;
        long t4=100000L;
        // 小数:浮点型
        float f1=3.9F;
        double f2=454.345;//更大
        //字符，和ASCII码相关
        char grade='A';
        //字符串，String 类

        //布尔型
        boolean b=false;
    }
}

双击shift问题

一、引言
我们在使用IDEA时，有时候在切换中英文输入法的时候，会不小心按了两次shift键，从而弹出 全局搜索框 ，让人不耐其烦，每次都要手动关闭这个搜索框。
二、取消双击shift
---------------------------------------2021.2.2版本之前
1.按ctrl+shift+alt+/ 在弹出的框中选择注册表(registry…)
2.找到ide.suppress.double.click.handler选项，选中打上勾，然后点close。
---------------------------------------2021.2.2版本及之后
File=> Settings=> Advanced Settings=> User Interface=> 选中“Disable double modifier key shortcuts”

扩展：
整数进制转换
浮点数问题
float和double是有限的，离散的，会四舍五入，都是约等于
所以有时候float类型的不等于double类型，因为舍入的精确位数不同
如果银行业务需要更高的精度，使用BigDecimal类
字符的本质都是数字，各种编码表示，比如中文也是一个数字，转义字符比如\n,\t,\a…

类型转换
低----------------------------------------------------------->高
byte,short,char–>int–>long–>float–>double

• 强制类型转换 (int)a 高到低，可能出现内存溢出
• 自动类型转换 低到高顺其自然即可

三、变量、常量、作用域

Java变量是程序中最基本的存储单元，包括了变量名，变量类型和作用域。

• 变量必须声明它的类型
• 变量名必须合法
• 变量声明以分号结尾

public class Demo4 {
    // 属性：变量
    static int classVariable=0;
    // 常量
    static final double PI=3.1415926;
    // main
    String str="hhh";
    public static void main(String[] args) {
        //局部变量：声明并初始化才可使用
        float f=1.1f;
        //调用实例变量，属于对象，new 对象即可使用
        System.out.println(new Demo4().str);;
    }
    // 方法
    public void fun() {

    }
} 

常量使用关键字final 定义，是一个特殊的变量，值不会被改变。

变量的命名规范

• 所有变量、方法、类名最好见名知意
• 类成员 变量驼峰式命名testFirst
• 常量 大写和下划线组成
• 类名 首字母大写，并且使用驼峰式
• 方法名 首字母小写和驼峰式

四、运算符

Math类是很方便的算术工具类 Math写了之后很多方法都可以点出来

public class Demo6Summary {
    public static void main(String[] args) {
        int a = 10;int b = 20;
        a+=b; //a = a+b
        a-=b; //a = a-b
        System.out.println(a);
        //字符串连接符+ , string
        System.out.println(""+a+b);//输出字符串
        System.out.println(a+b+"");//运算后变成字符串
        //理解优先级，优先级高的先运算，最高的是()
    }
}

五、包机制、JavaDoc

包的本质就是文件夹
作用：命名可能会出现很多重复，用包隔开文件即可重复命名并不冲突。

//包语句语法格式，文件夹分别后会自动加在第一行
package p1.[p2.[p3...]];
//一般利用域名倒置作为包名
//为了使用某个包中的成员，可以导入该包使用，语法如下
import p1.[p2.[p3...]].classname|*

JavaDoc（文档注释）
javadoc在命令行中可以生成自己的

/**
 * @author along
 * @version jdk9
 */
public class Doc{
    /**
     * 求输入两个参数范围以内整数的和
     * @param n 接收的第一个参数，范围起点
     * @param m 接收的第二个参数，范围终点
     * @return 两个参数范围以内整数的和
     */
    public int add(int n, int m) {
        int sum = 0;
        for (int i = n; i <= m; i++) {
            sum = sum + i;
        }
        return sum;
    }
} 

在文件所在文件夹中打开cmd 运行“javadoc -encoding UTF-8 -charset UTF-8 Doc.java ” 因为出现乱码，所以加了这两个字符集设置。

最后可以生成Doc相关的API网页

Java进阶语法

---

一、Scanner用户交互（输入）

---

用户交互是在java.util中的Scanner，要导入所在包
基本语法：

Scanner sc = new Scanner(System.in);

通过Scanner类的next()和nextLine()方法拿到输入的字符串，判断是否还有输入的方法是hasNext()和hasNextLine()

import java.util.Scanner;

public class Demo1 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("next接收：");
        if(sc.hasNext()){
            int number=sc.nextInt();
            System.out.println(number);
        }
        //IO流的类最好用完就关闭，否则会占用资源
        sc.close();
    }
}

其中next()接收遇到空格会停止，nextLine()读取行

package com.along2;

import java.util.Scanner;

public class Demo2 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        if(sc.hasNextInt()){
            int num=sc.nextInt();
            System.out.println(String.format("输出num=%d", num));
        }else{
            System.out.println("请输入整数！！");
        }
        sc.close();
    }
}

二、for迭代器（debug学习）

---

if,else,switch,break,continue省略，几乎每个语言都有，差别不大
while，dowhile，for基础也差不多

package com.along2;

public class Demo3 {
    public static void main(String[] args) {
        int [] a={1,2,3,4,5,6,7,8};
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
        for(int x:a){
            System.out.println(x);
        }
    }
}

学习debug

用循环控制*符号设计一个梯形

package com.along2;

public class Demo4 {
    public static void main(String[] args) {
        for(int i=0;i<4;i++){
            if(i<1)continue;
            for(int j=4;j>i;j--){
                System.out.print(" ");
            }
            for(int j=0;j<2*i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

三、方法

---

Java中的方法就是C中的函数
多出复用的功能，可以用一个方法来表达

方法的语法

修饰符 返回值类型 方法名(参数类型,参数名){
	方法体
	return 返回值;
}
public class Demo3 {
    public static void main(String[] args) {
        System.out.println(compareMax(2,4));
    }

    private static int compareMax(int a,int b) {
        return a>b?a:b;
    }
}

方法的重载

package com.along2;

public class Demo3 {
    public static void main(String[] args) {
        System.out.println(compareMax(2.6,4.9));//double
        System.out.println(compareMax(2,4));//int
        System.out.println(compareMax(2,4,9));//int3
        System.out.println(compareMax(66,'A'));//intt-char

    }

    private static double compareMax(double a,double b) {
        return a>b?a:b;
    }
    private static int compareMax(int a,int b) {
        return a>b?a:b;
    }
    private static int compareMax(int a,int b,int c) {
        return a>b? Math.max(a, c) : Math.max(b, c);
    }
    private static String  compareMax(int a,char b) {
        return a>b?"a":"b";
    }
}

命令行传参

package com.along2;

public class Demo4 {
    public static void main(String[] args) {
        for (int i=0;i<args.length;i++){
            System.out.println(args[i]);
        }
    }
}

注意

• 需要先生成class文件
• 去src目录下查找该包名，输入args数组参数即可

可变参数

在方法声明中指定参数类型后加（…）省略号
一个方法只能指定一个可变参数并只能在最后面声明
作用
在不确定参数的个数时，可以使用可变参数

package com.along2;

public class Demo5 {
    public static void main(String[] args) {
        compareMax(new int[] {1,2,3});
        compareMax(1,2,3,4);
    }
    private static void compareMax(int[] ...number) {
        if(number.length==0){
            System.out.println("problem！");
            return;
        }
        // 和传递数组的表示不一样number迭代器使用时并不是一个数组对象,我定义一个函数去生成的时候它是二维数组
        System.out.println(getType(number));
    }

    private static String getType(int[][] number) {
        return "test";
    }
    private static void compareMax(int ...number) {
        if(number.length==0){
            System.out.println("problem！");
            return;
        }
        // 这里是一维数组，那么可以看出根据传递的类型，在基础上套一个数组
        System.out.println(getType_int(number));
    }

    private static String getType_int(int[] number) {
        return "test_int";
    }

}

递归

四、数组

---

数组的语法

用上面的，下面的也能用C语言的风格数组被弃用的变量（C-sytle array declaration of local variable）

new数组方法

package com.Arrays;

import java.util.Scanner;

public class ArraysDemo1 {
    public static void main(String[] args) {
        int[] numbers;
        int numbers2[];
        Scanner sc=new Scanner(System.in);
        int[] numbers3=new int[10];
        for (int i=0;i<numbers3.length;i++){
            numbers3[i]=sc.nextInt();
        }
        for (int i:numbers3) {
            System.out.print(i+" ");
        }
    }
}

内存分析

数组的特点

• 数组长度是确定的，大小不可改变
• 元素类型必须相同
• 数组的元素可以是任何类型
• 数组属于引用类型，**可以看成对象，**每个元素看成成员变量
• 数组的对象本身是在堆中的

数组使用

• foreach迭代器的使用
• 可以当成传参类型
• 数组作为返回值
• 多维数组：一维一个[],多维多个[],定义方式和一维的类似

Arrays类

Java API
链接：https://pan.baidu.com/s/1ySMt-rKW4d4J1CGd0nKkdQ
提取码：0303
Java API的介绍截图不知为啥违规，有需要下载自查


注意
工具类的方法很好用，需要的时候可以查API并使用，也可以自己写，或者模仿源码的方法去写，ctrl可以点击进去。

扩展 稀疏数组（当成数据结构算法来尝试下）

五、面向对象（OOP, Object Oriented Programming）

---

面向过程和面向对象的区别

面向过程
优点：性能比面向对象好，因为类调用时需要实例化，开销比较大，比较消耗资源。
缺点：不易维护、不易复用、不易扩展

面向对象
优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护
缺点：性能比面向过程差

方法进阶

修饰符 返回值类型 方法名（）[异常抛出]{
    return 返回值（要和类型匹配）；
}

如果是不是static 修饰的方法，其他类只有实例化（new）才能调用，反之可以在import后根据类名直接调用。

引用传递和值传递
值传递(pass by value)：在调用函数时，将实际参数复制一份传递到函数中，这样在函数中对参数进行修改，就不会影响到原来的实际参数；

引用传递(pass by reference):在调用函数时，将实际参数的地址直接传递到函数中。这样在函数中对参数进行的修改，就会影响到实际参数；

package com.OOP;

public class Demo2 {
    public static void main(String[] args) {
        Person person=new Person();//实例化对象
        System.out.println(person.name);//并未传值，故为null
        Demo2.change(person);//调用赋值函数change
        System.out.println(person.name);//给person对象所在地址的name属性赋值
    }

    private static void change(Person person) {
        person.name="hah ";
    }
}

class Person{
    String name;
}

创建对象

“new 对象后.var可以自动创建一个变量”
Ctrl +Alt + L代码格式调整

package com.OOP;

// 一个项目应该只有一个main方法
public class Application {
    public static void main(String[] args) {
        //类：new出来之后 stu1和stu2是独立的个体
        Student stu1 = new Student();
        Student stu2 = new Student();
        stu1.name="小一";
        stu2.name="小二";
        System.out.println(stu1.name);
        System.out.println(stu2.name);
    }
}

构造器

快速提示完成，在代码可能存在语法问题时，IDEA 会提示使用该快捷键可以快速自动修正（功能非常强大，最常使用） Alt + Enter
快速生成含有任意形参的构造器，和私有属性的 Getter / Setter 方法等（最常使用） Alt + insert

• 创建对象
• 初始化成员变量
• 使用new关键字必须要有构造器

特点

1. 构造方法的方法名要与类名一致
2. 构造方法分为：有参构造方法和无参构造方法
3. 构造方法无返回类型，void类型也不可以
4. 构造方法是不能被继承的，但是可以使用super来调用，且super必须声明在在子类构造方法中的首行
5. 默认有一个无参构造方法，当自定义无参构造方法的时候，默认则无效
6. 可以没有构造方法（编译器默认有一个无参构造方法），也可以有多个构造方法，他们之间构成重载关系

/* 类和对象
            类是一个模板,对象new出来就是实例，可以用
         引用类型
            对象通过引用从栈中将执行操作放在堆中执行
          属性：字段Field 成员变量
          初始化字段 数字 0 0.0
                    char /u0000
                    boolean false
                    引用类型 null
          类
            静态的属性  属性
            动态的行为  方法
*/

“高内聚，低耦合”
"高内聚，低耦合"是内部自己操作，少量方法给外部使用。
面向对象的三大特性

1. 封装
   隐藏对象的属性和实现细节，仅对外提供公共访问方式，将变化隔离，便于使用，提高复用性和安全性，可以使用get/set来对变量修改和访问，为啥会封起来是因为可以不写get的方法，这样就只能写进去无法查看，保护了隐私。

• 可以提高程序的安全性，保护数据
• 隐藏代码的细节
• 统一接口且增加了系统可维护性
  

3. 继承
   提高代码复用性；继承是多态的前提。
4. 多态
   父类或接口定义的引用变量可以指向子类或具体实现类的实例对象。提高了程序的拓展性。

五大基本原则（约定俗成开发的原则）
5. 单一职责原则SRP(Single Responsibility Principle)
类的功能要单一，不能包罗万象，跟杂货铺似的。

6. 开放封闭原则OCP(Open－Close Principle)
   一个模块对于拓展是开放的，对于修改是封闭的，可增加功能，不能修改功能。

7. 里式替换原则LSP(the Liskov Substitution Principle LSP)
   子类可以替换父类出现在父类能够出现的任何地方。比如你能代表你爸去你姥姥家干活。哈哈~~

8. 依赖倒置原则DIP(the Dependency Inversion Principle DIP)
   高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象。抽象不应该依赖于具体实现，具体实现应该依赖于抽象。就是你出国要说你是中国人，而不能说你是哪个村子的。比如说中国人是抽象的，下面有具体的xx省，xx市，xx县。你要依赖的抽象是中国人，而不是你是xx村的。

9. 接口分离原则ISP(the Interface Segregation Principle ISP)
   设计时采用多个与特定客户类有关的接口比采用一个通用的接口要好。就比如一个手机拥有打电话，看视频，玩游戏等功能，把这几个功能拆分成不同的接口，比在一个接口里要好的多。

总结
抽象的思维将问题分解成一个个模块，会使复杂的问题更加简单化。
从以前面向过程的执行者转向了领导者，也就是从码农变成了技术总监。
面向对象更符合人类的思维，面向过程则是机器的思想。

六、异常

---

---

Java特性和优势

---

• 简单性
• 面向对象
• 可移植性
• 高性能
• 分布式
• 动态性
• 多线程
• 安全性
• 健壮性

java三大版本

---

• JavaSE:标准版，java基础*
• JavaME:嵌入式开发
• JavaEE:企业级开发，web开发*

JDK、JRE、JVM(从前到后包含)

---

Java开发环境搭建步骤

---

• JDK下载安装
• 配置环境变量
• 网上找教程安装即可

Java程序运行机制

---

• 编译型:用编译器把整个程序.java 编译成.class（操作系统要求低）
• 解释型:实时解释程序语句（速度快）
• 程序运行机制
  

IDE

---

IDE(集成开发环境)
Java常用的IDE：Eclipse、Idea…

Java基础语法

一、注释、标识符、关键字

---

注释：

• 结构复杂需要使用
• 注释给开发人员看的
• 写注释是一个合格的开发者必备修养

Java注释的三种方式：

• 单行注释
• 多行注释
• 文档注释

public class demo1 {
    public static void main(String[] args) {
        //单行注释
        /*
        * 多
        * 行
        * 注
        * 释
        * */
        /** @Description 文档注释，写的会比较少
         *  @Author along
         *  */
        System.out.println("demo!");
    }
} 

标识符：

Java所有的组成部分都需要名字，比如类名、方法名、变量名都是标识符。
注意点：

• 标识符首字符由字母、下划线、$开始
• 变量由字母、下划线、$、数字组成
• 变量不能以数字开头，可以用中文但不必要

二、数据类型（shift双击问题）

• 强类型语言
• • 要求变量使用严格符合规定，所有变量需要先定义才能使用，安全性高。
• 弱类型语言

Java数据类型分类

public class Demo2 {
    public static void main(String[] args) {
        // 八大基本类型
        // 整数
        int t1=65536*32767;
        byte t2=127;
        short t3=32767;
        long t4=100000L;
        // 小数:浮点型
        float f1=3.9F;
        double f2=454.345;//更大
        //字符，和ASCII码相关
        char grade='A';
        //字符串，String 类

        //布尔型
        boolean b=false;
    }
}

双击shift问题

一、引言
我们在使用IDEA时，有时候在切换中英文输入法的时候，会不小心按了两次shift键，从而弹出 全局搜索框 ，让人不耐其烦，每次都要手动关闭这个搜索框。
二、取消双击shift
1.按ctrl+shift+alt+/ 在弹出的框中选择注册表(registry…)
2.找到ide.suppress.double.click.handler选项，选中打上勾，然后点close。

扩展：
整数进制转换
浮点数问题
float和double是有限的，离散的，会四舍五入，都是约等于
所以有时候float类型的不等于double类型，因为舍入的精确位数不同
如果银行业务需要更高的精度，使用BigDecimal类
字符的本质都是数字，各种编码表示，比如中文也是一个数字，转义字符比如\n,\t,\a…

类型转换
低----------------------------------------------------------->高
byte,short,char–>int–>long–>float–>double

• 强制类型转换 (int)a 高到低，可能出现内存溢出
• 自动类型转换 低到高顺其自然即可

三、变量、常量、作用域

Java变量是程序中最基本的存储单元，包括了变量名，变量类型和作用域。

• 变量必须声明它的类型
• 变量名必须合法
• 变量声明以分号结尾

public class Demo4 {
    // 属性：变量
    static int classVariable=0;
    // 常量
    static final double PI=3.1415926;
    // main
    String str="hhh";
    public static void main(String[] args) {
        //局部变量：声明并初始化才可使用
        float f=1.1f;
        //调用实例变量，属于对象，new 对象即可使用
        System.out.println(new Demo4().str);;
    }
    // 方法
    public void fun() {

    }
} 

常量使用关键字final 定义，是一个特殊的变量，值不会被改变。

变量的命名规范

• 所有变量、方法、类名最好见名知意
• 类成员 变量驼峰式命名testFirst
• 常量 大写和下划线组成
• 类名 首字母大写，并且使用驼峰式
• 方法名 首字母小写和驼峰式

四、运算符

Math类是很方便的算术工具类 Math写了之后很多方法都可以点出来

public class Demo6Summary {
    public static void main(String[] args) {
        int a = 10;int b = 20;
        a+=b; //a = a+b
        a-=b; //a = a-b
        System.out.println(a);
        //字符串连接符+ , string
        System.out.println(""+a+b);//输出字符串
        System.out.println(a+b+"");//运算后变成字符串
        //理解优先级，优先级高的先运算，最高的是()
    }
}

五、包机制、JavaDoc

包的本质就是文件夹
作用：命名可能会出现很多重复，用包隔开文件即可重复命名并不冲突。

//包语句语法格式，文件夹分别后会自动加在第一行
package p1.[p2.[p3...]];
//一般利用域名倒置作为包名
//为了使用某个包中的成员，可以导入该包使用，语法如下
import p1.[p2.[p3...]].classname|*

JavaDoc（文档注释）
javadoc在命令行中可以生成自己的

/**
 * @author along
 * @version jdk9
 */
public class Doc{
    /**
     * 求输入两个参数范围以内整数的和
     * @param n 接收的第一个参数，范围起点
     * @param m 接收的第二个参数，范围终点
     * @return 两个参数范围以内整数的和
     */
    public int add(int n, int m) {
        int sum = 0;
        for (int i = n; i <= m; i++) {
            sum = sum + i;
        }
        return sum;
    }
} 

在文件所在文件夹中打开cmd 运行“javadoc -encoding UTF-8 -charset UTF-8 Doc.java ” 因为出现乱码，所以加了这两个字符集设置。

最后可以生成Doc相关的API网页

Java进阶语法

---

一、Scanner用户交互（输入）

---

用户交互是在java.util中的Scanner，要导入所在包
基本语法：

Scanner sc = new Scanner(System.in);

通过Scanner类的next()和nextLine()方法拿到输入的字符串，判断是否还有输入的方法是hasNext()和hasNextLine()

import java.util.Scanner;

public class Demo1 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("next接收：");
        if(sc.hasNext()){
            int number=sc.nextInt();
            System.out.println(number);
        }
        //IO流的类最好用完就关闭，否则会占用资源
        sc.close();
    }
}

其中next()接收遇到空格会停止，nextLine()读取行

package com.along2;

import java.util.Scanner;

public class Demo2 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        if(sc.hasNextInt()){
            int num=sc.nextInt();
            System.out.println(String.format("输出num=%d", num));
        }else{
            System.out.println("请输入整数！！");
        }
        sc.close();
    }
}

二、for迭代器（debug学习）

---

if,else,switch,break,continue省略，几乎每个语言都有，差别不大
while，dowhile，for基础也差不多

package com.along2;

public class Demo3 {
    public static void main(String[] args) {
        int [] a={1,2,3,4,5,6,7,8};
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
        for(int x:a){
            System.out.println(x);
        }
    }
}

学习debug

用循环控制*符号设计一个梯形

package com.along2;

public class Demo4 {
    public static void main(String[] args) {
        for(int i=0;i<4;i++){
            if(i<1)continue;
            for(int j=4;j>i;j--){
                System.out.print(" ");
            }
            for(int j=0;j<2*i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

三、方法

---

Java中的方法就是C中的函数
多出复用的功能，可以用一个方法来表达

方法的语法

修饰符 返回值类型 方法名(参数类型,参数名){
	方法体
	return 返回值;
}
public class Demo3 {
    public static void main(String[] args) {
        System.out.println(compareMax(2,4));
    }

    private static int compareMax(int a,int b) {
        return a>b?a:b;
    }
}

方法的重载

package com.along2;

public class Demo3 {
    public static void main(String[] args) {
        System.out.println(compareMax(2.6,4.9));//double
        System.out.println(compareMax(2,4));//int
        System.out.println(compareMax(2,4,9));//int3
        System.out.println(compareMax(66,'A'));//intt-char

    }

    private static double compareMax(double a,double b) {
        return a>b?a:b;
    }
    private static int compareMax(int a,int b) {
        return a>b?a:b;
    }
    private static int compareMax(int a,int b,int c) {
        return a>b? Math.max(a, c) : Math.max(b, c);
    }
    private static String  compareMax(int a,char b) {
        return a>b?"a":"b";
    }
}

命令行传参

package com.along2;

public class Demo4 {
    public static void main(String[] args) {
        for (int i=0;i<args.length;i++){
            System.out.println(args[i]);
        }
    }
}

注意

• 需要先生成class文件
• 去src目录下查找该包名，输入args数组参数即可

可变参数

在方法声明中指定参数类型后加（…）省略号
一个方法只能指定一个可变参数并只能在最后面声明
作用
在不确定参数的个数时，可以使用可变参数

package com.along2;

public class Demo5 {
    public static void main(String[] args) {
        compareMax(new int[] {1,2,3});
        compareMax(1,2,3,4);
    }
    private static void compareMax(int[] ...number) {
        if(number.length==0){
            System.out.println("problem！");
            return;
        }
        // 和传递数组的表示不一样number迭代器使用时并不是一个数组对象,我定义一个函数去生成的时候它是二维数组
        System.out.println(getType(number));
    }

    private static String getType(int[][] number) {
        return "test";
    }
    private static void compareMax(int ...number) {
        if(number.length==0){
            System.out.println("problem！");
            return;
        }
        // 这里是一维数组，那么可以看出根据传递的类型，在基础上套一个数组
        System.out.println(getType_int(number));
    }

    private static String getType_int(int[] number) {
        return "test_int";
    }

}

递归

四、数组

---

数组的语法

用上面的，下面的也能用C语言的风格数组被弃用的变量（C-sytle array declaration of local variable）

new数组方法

package com.Arrays;

import java.util.Scanner;

public class ArraysDemo1 {
    public static void main(String[] args) {
        int[] numbers;
        int numbers2[];
        Scanner sc=new Scanner(System.in);
        int[] numbers3=new int[10];
        for (int i=0;i<numbers3.length;i++){
            numbers3[i]=sc.nextInt();
        }
        for (int i:numbers3) {
            System.out.print(i+" ");
        }
    }
}

内存分析

数组的特点

• 数组长度是确定的，大小不可改变
• 元素类型必须相同
• 数组的元素可以是任何类型
• 数组属于引用类型，**可以看成对象，**每个元素看成成员变量
• 数组的对象本身是在堆中的

数组使用

• foreach迭代器的使用
• 可以当成传参类型
• 数组作为返回值
• 多维数组：一维一个[],多维多个[],定义方式和一维的类似

Arrays类

Java API
链接：https://pan.baidu.com/s/1ySMt-rKW4d4J1CGd0nKkdQ
提取码：0303
Java API的介绍截图不知为啥违规，有需要下载自查


注意
工具类的方法很好用，需要的时候可以查API并使用，也可以自己写，或者模仿源码的方法去写，ctrl可以点击进去。

扩展 稀疏数组（当成数据结构算法来尝试下）

五、面向对象（OOP, Object Oriented Programming）

---

面向过程和面向对象的区别

面向过程
优点：性能比面向对象好，因为类调用时需要实例化，开销比较大，比较消耗资源。
缺点：不易维护、不易复用、不易扩展

面向对象
优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护
缺点：性能比面向过程差

方法进阶

修饰符 返回值类型 方法名（）[异常抛出]{
    return 返回值（要和类型匹配）；
}

如果是不是static 修饰的方法，其他类只有实例化（new）才能调用，反之可以在import后根据类名直接调用。

引用传递和值传递
值传递(pass by value)：在调用函数时，将实际参数复制一份传递到函数中，这样在函数中对参数进行修改，就不会影响到原来的实际参数；

引用传递(pass by reference):在调用函数时，将实际参数的地址直接传递到函数中。这样在函数中对参数进行的修改，就会影响到实际参数；

package com.OOP;

public class Demo2 {
    public static void main(String[] args) {
        Person person=new Person();//实例化对象
        System.out.println(person.name);//并未传值，故为null
        Demo2.change(person);//调用赋值函数change
        System.out.println(person.name);//给person对象所在地址的name属性赋值
    }

    private static void change(Person person) {
        person.name="hah ";
    }
}

class Person{
    String name;
}

创建对象

“new 对象后.var可以自动创建一个变量”
Ctrl +Alt + L代码格式调整

package com.OOP;

// 一个项目应该只有一个main方法
public class Application {
    public static void main(String[] args) {
        //类：new出来之后 stu1和stu2是独立的个体
        Student stu1 = new Student();
        Student stu2 = new Student();
        stu1.name="小一";
        stu2.name="小二";
        System.out.println(stu1.name);
        System.out.println(stu2.name);
    }
}

构造器

快速提示完成，在代码可能存在语法问题时，IDEA 会提示使用该快捷键可以快速自动修正（功能非常强大，最常使用） Alt + Enter
快速生成含有任意形参的构造器，和私有属性的 Getter / Setter 方法等（最常使用） Alt + insert

• 创建对象
• 初始化成员变量
• 使用new关键字必须要有构造器

特点

1. 构造方法的方法名要与类名一致
2. 构造方法分为：有参构造方法和无参构造方法
3. 构造方法无返回类型，void类型也不可以
4. 构造方法是不能被继承的，但是可以使用super来调用，且super必须声明在在子类构造方法中的首行
5. 默认有一个无参构造方法，当自定义无参构造方法的时候，默认则无效
6. 可以没有构造方法（编译器默认有一个无参构造方法），也可以有多个构造方法，他们之间构成重载关系

/* 类和对象
            类是一个模板,对象new出来就是实例，可以用
         引用类型
            对象通过引用从栈中将执行操作放在堆中执行
          属性：字段Field 成员变量
          初始化字段 数字 0 0.0
                    char /u0000
                    boolean false
                    引用类型 null
          类
            静态的属性  属性
            动态的行为  方法
*/

“高内聚，低耦合”
"高内聚，低耦合"是内部自己操作，少量方法给外部使用。
面向对象的三大特性

1. 封装
   隐藏对象的属性和实现细节，仅对外提供公共访问方式，将变化隔离，便于使用，提高复用性和安全性，可以使用get/set来对变量修改和访问，为啥会封起来是因为可以不写get的方法，这样就只能写进去无法查看，保护了隐私。

• 可以提高程序的安全性，保护数据
• 隐藏代码的细节
• 统一接口且增加了系统可维护性
  

2. 继承
   提高代码复用性；继承是多态的前提。

• Java只有单继承，继承是独立的个体，只是可以使用父类的公有属性和方法，还可以重写父类的方法增加功能
• 不能继承父类的构造器
• 子类可以继承父类的私有成员，但是不能访问。
• Ctrl+H可以打开该类和其他类之间的关系
• 所有类的父类是Object类
• 继承后的默认值可以使用，但是新赋值的数据是独立的
  理解：因为面向对象和人的思维很匹配，那继承其实就是父子关系，父亲有自己的盆友（属性值），你也会有自己的朋友（属性值），所以即使你认识你父亲的朋友那你最多叫他叔叔，那也不是你的朋友（属性值相互独立）；父亲的财产和公司你可以继承（属性和方法）；父亲公司做的东西，你继承之后是不是一定要按部就班呢？做了老板是否会有自己的小九九呢，比如继承了父亲的公司，父亲卖电器的，你可以做游戏开发（重写父类的方法），父亲的身份证你不能使用吧（构造器不被集继承）…
  
  重写的写法（必须要public,不能重写静态方法即static修饰）
  

3. 多态
   父类或接口定义的引用变量可以指向子类或具体实现类的实例对象。提高了程序的拓展性。
   前提：

• 有继承关系
• 子类重写父类方法
• 父类引用指向子类对象
• 多态是关于方法的多态，属性无多态

多态的转型
向上转型：多态本身就是向上转型过的过程

• 使用格式：父类类型 变量名=new 子类类型();
• 适用场景：当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作。

向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用类型转为子类引用各类型

• 使用格式：子类类型 变量名=（子类类型） 父类类型的变量；
• 适用场景：当要使用子类特有功能时。

package com.OOP;

public class MoreStatus {
    public static void main(String[] args) {
        Car c1=new Ford();//向下转型
        Ford c2=new Ford();
        Object c3=new Ford();
        Ford c4= (Ford) c1;//向上转型
        c1.run();
        ((Ford) c1).fly();
        c4.special();
    }
}
class Car{
    private String name;
    private String category;
    private String price;
    public float speed_per_s=100;

    public void run() {
        System.out.println("我的速度是"+speed_per_s);
    }
    public void special() {
        System.out.println("我是Car");
    }
}
class Ford extends Car{
    @Override
    public void run() {
        System.out.println("Ford我的速度是"+speed_per_s);
    }
    public void fly(){
        System.out.println("我会飞");
    }
}

static 关键字

在类中，用static声明的成员变量为静态成员变量，也成为类变量。类变量的生命周期和类相同，在整个应用程序执行期间都有效。下面很详细的说明了static变量，代码块等等区别和速度。

https://blog.csdn.net/kuangay/article/details/81485324

抽象类（abstract）

五大基本原则（约定俗成开发的原则）

1. 单一职责原则SRP(Single Responsibility Principle)
   类的功能要单一，不能包罗万象，跟杂货铺似的。

2. 开放封闭原则OCP(Open－Close Principle)
   一个模块对于拓展是开放的，对于修改是封闭的，可增加功能，不能修改功能。

3. 里式替换原则LSP(the Liskov Substitution Principle LSP)
   子类可以替换父类出现在父类能够出现的任何地方。比如你能代表你爸去你姥姥家干活。哈哈~~

4. 依赖倒置原则DIP(the Dependency Inversion Principle DIP)
   高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象。抽象不应该依赖于具体实现，具体实现应该依赖于抽象。就是你出国要说你是中国人，而不能说你是哪个村子的。比如说中国人是抽象的，下面有具体的xx省，xx市，xx县。你要依赖的抽象是中国人，而不是你是xx村的。

5. 接口分离原则ISP(the Interface Segregation Principle ISP)
   设计时采用多个与特定客户类有关的接口比采用一个通用的接口要好。就比如一个手机拥有打电话，看视频，玩游戏等功能，把这几个功能拆分成不同的接口，比在一个接口里要好的多。

总结
抽象的思维将问题分解成一个个模块，会使复杂的问题更加简单化。
从以前面向过程的执行者转向了领导者，也就是从码农变成了技术总监。
面向对象更符合人类的思维，面向过程则是机器的思想。

六、异常

---