JAVA总结1

## 一:变量
```java
// 数据类型 变量名称 = 数据 
int age = 18;
```
## 二:命名规范
①项目名/模块名/数据库表名/列名:全小写,多个单词用__连接
②包名:全小写,域名倒序
③类名:首字母大写,驼峰模式
④变量名/方法名:首字母小写,驼峰模式
## 三.数据类型
⭐基本数据类型：
①整型：byte short int long
②浮点型（小数）：float double
③字符型：char
④布尔型:boolean
⭐引用数据类型：String类型
## 四.类型转换
让不同类型的数据能够进行运算或赋值
#### ①自动类型转换：
低精度→高精度（例如从整型到浮点型的转换）
char可以转换为int类型
```java
        //自动类型转换：int转为double
        int n = 10;
        double b = n;
        System.out.println(b);// 10.0
```
⭐表达式的自动类型转换：
表达式的最终结果类型由表达式中的最高类型决定
byte,short,char是直接转换成Int类型参与运算的
#### ②强制类型转换：
高精度→低精度
```java
        // 强制类型转换：double转为int,截断小数保留整数
        // 强制类型转换快捷键：alt+回车 再回车 
        double d = 10.5;
        int i = (int)d;
        System.out.println(i);// 10
```
## 五.运算符
#### ①基本的算术运算符
⭐/:两个整数相除，结果还是整数（因为最高类型是整数）
⭐%:取余
⭐+：与字符串运算的时候是用作连接符的，结果依然是一个字符串
#### ②自增自减运算符
只能操作变量，不能操作字面量
```java
// 报错
 System.out.println(2++);
```
⭐放在变量前面：先对变量进行+1，-1，再拿变量的值进行运算
⭐放在变量后面：先拿变量的值进行运算，再对变量的值进行+1，-1
```java
        // 先加后运算
        int o = 10;
        int w = ++o;
        System.out.println(w);// 11
        System.out.println(o);// 11
        // 先运算后加
        int q = 5;
        int r = q++;
        System.out.println(q);// 6
        System.out.println(r);// 5
```
#### ③关系运算符
⭐>=:大于或者等于  
⭐<=:小于或者等于  
⭐==:等于  
⭐！=：不等于
布尔值判断真假
#### ④逻辑运算符
⭐&和&&：
全部都是true,结果才是true；有一个是false，结果为false
&&：前一个为false,后一个不进行判断了
⭐|和||：只要有一个是true，结果就是true
||:前一个为true,后一个不进行判断了
⭐非（！）：你真我假，你假我真
⭐逻辑异或（∧）：前后条件结果相同，为false;前后条件结果不同，为true
#### ⑤三元运算符
格式： 条件表达式？值1：值2；
流程：首先计算关系表达式的值，如果值为true,返回值1；如果为false,返回值2
## 六.静态初始化数组
定义数组的时候，直接给数组赋值
#### ①定义格式
```java
        // 静态数组格式：
        // 数据类型[] 数组名 = {元素1，元素2...}；
               int[]  ages = {12,24,36};
        // 数据变量名中存储的是数组在内存中的地址
        System.out.println(ages); // [I@4eec7777
```
#### ②数组的访问
数组名称[索引]
#### ③数组的长度属性：
数组名.length
#### ④数组的最大索引：
数组名.length-1
```java
        // TODO 掌握数组的访问
        int[] arr = {12,24,36};
        // 0  1  2
        // 1.访问数组的全部数据
        System.out.println(arr[0]); // 12

        // 2.修改数组中的数据
        arr[0] = 66;
        System.out.println(arr[0]); // 66

        // 3.访问数组的元素个数  数组名.length
        System.out.println(arr.length); // 3

        //4.：获取数据的最大索引  arr.length - 1 (前提是数组中存在数据)
        System.out.println(arr.length - 1); // 2
```
#### ⑤数组的遍历
一个一个的访问一遍容器中的数据
```java
        int[] ages = {12,24,36};
        for (int i = 0; i < ages.length; i++) {
            System.out.println(ages[i]); // 12 24 36
        }
```
## 七.动态初始化数组
定义数组时先不存入具体的元素值，只确定数组存储的数据类型和数组的长度
#### 定义格式
```java
        // 定义格式： 数据类型[] 数组名 = new 数据类型[长度]
              int[] ages = new int[3] ;//ages = [0,0,0]
        // 赋值
        ages[0] = 12;
        System.out.println(ages[0]); // 12
```
## 八.分支结构
#### ①if分支：可以根据条件，选择执行某段代码
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/09d7ea5c-63b3-27e2-7ad6-164fe17cc058.png)
```java
        // TODO 掌握if分支三种形式的用法和执行流程
        // 需求1：测量用户体温，高于37度就报警
        double t = 38.9;
        if ( t > 37 ){
            System.out.println("体温异常");// 体温异常
        }

        // 需求2；发红包：余额99元，发出90元。余额够，发红包；余额不足则需提示
        double money = 82;
        if (money >= 90){
            System.out.println("发红包！");
        }else {
            System.out.println("余额不足"); // 余额不足
        }

        // 需求3：绩效系统根据员工打分输出对应的绩效级别
        //0-60；D    60-80：C      80-90：B     90-100：A
        int score = 78;
        if (score >= 0 && score < 60){
            System.out.println("D");
        } else if (score >= 60 && score < 80) {
            System.out.println("C"); // c
        }else if (score >= 80 && score < 90) {
            System.out.println("B");
        }else if (score >= 90 && score <= 100) {
            System.out.println("A");
        }else {
            System.out.println("输入错误");
        }
```
#### ②switch分支：通过比较值来决定执行哪条分支
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/731aa899-8e36-8933-5911-8a1e35dde821.png)
```java
// TODO 掌握switch的写法，理解其执行流程
        String week = "周日";
        switch(week){  // 周日 777
            case "周一":
                System.out.println("111");
                break;
            case "周二":
                System.out.println("222");
                break;
            case "周三":
                System.out.println("333");
                break;
            case "周四":
                System.out.println("444");
                break;
            case "周五":
                System.out.println("555");
                break;
            case "周六":
                System.out.println("666");
                break;
            case "周日":
                System.out.println("777");
                break;
            default:
                System.out.println("其他");
        }
```
## 九.循环结构
#### ①for循环：控制一段代码反复执行多次
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/1f16ca01-1847-60fa-c479-c21ef40ca967.png)
#### ②while循环
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/f4eec480-329d-cb54-7910-ff0ebb9ce877.png)
#### ③循环嵌套：外部循环每循环一次，内部循环会全部执行完一轮
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/5e7020a6-9de1-581f-7471-cb613b3fffad.png)
## ⑩.跳转关键字
```java
        // TODO 掌握Break和Continue的作用
        // Break：跳出并结束当前所在循环的执行
        for (int i = 1; i <= 5 ; i++) {
            System.out.println(i);
            if (i==3){     //  1 2 3
                break;// 遇到break，整个循环就结束了。跳出循环执行后续的代码。
            }
        }

        
        //Continue:跳出当前循环的当次执行，直接进入循环的下一次执行
        for (int i = 1; i <= 5 ; i++) {
            if (i == 3){  // 1 2 4 5
                continue;// 遇到continue,当次循环结束，继续进行下一轮的循环
            }
            System.out.println(i);
        }
```
## 十.方法 
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/39d77dd6-3f74-4044-a403-f571c42f5a04.png)
## 十一.return关键字
单独使用在无返回值方法中的作用：跳出并立即结束当前方法的执行
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/f748dca6-dd2e-9401-2030-456b501cd78d.png)
## 十二.方法参数传递
基本类型传递的是：值的副本
引用类型传递的是：地址的副本
## 十三.封装 
之后成员变量都写为私有，用private修饰，写get/set方法。
## 十四.String的常用方法
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/0516c0a2-9234-5af1-ba40-f5781ad65c3b.png)
```java
 // TODO 掌握string提供的处理字符串的常用方法
        String s = "黑马Java";
        // 1.获取字符串的长度
        System.out.println(s.length());// 6

        // 2.提取字符串中某个索引位置处的字符
        char c = s.charAt(1);
        System.out.println(c);// 马

        // 字符串的遍历
        for (int i = 0; i < s.length(); i++) {
            // i = 0 1 2 3 4 5
            char ch = s.charAt(i);
            System.out.println(ch);// 黑马Java
        }

        // 3.把字符串转换成字符数组，再进行遍历
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);// 黑马Java
        }

        // 4.判断字符串内容，内容一样就返回true
        String s1 = new String("黑马");
        String s2 = new String("黑马");
        System.out.println(s1 == s2);//false
        System.out.println(s1.equals(s2));//true

        // 5.忽略大小写，比较字符串内容
        String c1 = "34AeFG";
        String c2 = "34aEfg";
        System.out.println(c1.equals(c2));//false
        System.out.println(c1.equalsIgnoreCase(c2));//true

        // 6.截取字符串内容
        String s3 = "Java是最好的编程语言之一";
        String rs = s3.substring(0,8);
        System.out.println(rs);// Java是最好的

        // 7.从当前索引位置一直截取到字符串的末尾
        String rs2 = s3.substring(5);
        System.out.println(rs2);// 最好的编程语言之一

        // 8.把字符串中的某个内容替换成新内容，并返回新的字符串对象给我们
        String info = "这个电影简直是个垃圾，垃圾电影";
        String rs3 =info.replace("垃圾","**");
        System.out.println(rs3);// 这个电影简直是个**，**电影

        // 9.判断字符串中是否包含某个关键字
        String info2 = "Java是最好的编程语言之一，我爱Java，Java不爱我";
        System.out.println(info2.contains("Java"));//true

        // 10.判断字符串是否以某个字符串开头，
        String rs4 = "张三";
        System.out.println(rs4.startsWith("张"));// true

        // 11.把字符串按照某个指定内容分割成多个字符串，放到一个字符串数组中，返回给我们
        String rs5 = "汪苏泷,魏大勋,李宇春";
        String[] names = rs5.split(",");
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);// 汪苏泷
                                        //魏大勋
                                       // 李宇春
```
## 十五.ArrayList集合
⭐数组定义完成并启动后，长度就固定了；集合大小可变，开发中用的更多
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/151d8c64-ce63-d0e6-a2cd-cd2b801e197a.png)
```java
       // 1.创建一个ArrayList的集合对象
        ArrayList<String> list = new ArrayList<>();

        list.add("黑马");
        list.add("黑马");
        list.add("Java");
        System.out.println(list);//[黑马, 黑马, Java]

        // 2.往集合中的某个索引位置处添加一个数据
        list.add(1,"MYSQL") ;
        System.out.println(list);// [黑马, MYSQL, 黑马, Java]

        // 3.根据索引获取集合中某个索引位置处的值
        String rs =list.get(1);
        System.out.println(rs);// MYSQL

        // 4.获取集合的大小，返回集合中存储的元素个数
        System.out.println(list.size());// 4

        // 5.根据索引删除集合中的某个元素值，会返回被删除的元素值给我们
        System.out.println(list.remove(1));// MYSQL
        System.out.println(list);// [黑马, 黑马, Java]

        // 6.直接删除某个元素值，删除成功会返回true,反之返回false
        System.out.println(list.remove("Java"));// true
        System.out.println(list);// [黑马, 黑马]

        list.add(1,"html");
        System.out.println(list);//[html, 黑马]

        // 默认删除的是第一次出现的这个黑马的数据的
        System.out.println(list.remove("黑马"));// true
        System.out.println(list);// [黑马]

        // 7.修改某个索引位置处的数据，修改后会返回原来的值给我们
        System.out.println(list.set(1, "黑马程序员"));// 黑马
        System.out.println(list);// [html, 黑马程序员]
```
## 十六.static（静态） 
#### ①修饰成员变量
有stati修饰：类变量（在计算机里只有一份，会被类的全部对象共享）
某个数据只需要一份，且希望能够被共享（访问，修改），则该数据可以被定义成类变量来记住。
⭐类名.类变量
```java
static String name;
```
无stati修饰：实例变量（属于每个对象的）
⭐对象.实例变量
```java
int age;
```
#### ②修饰成员方法
有stati修饰：类方法，属于类
⭐类名.类方法
无stati修饰：实例方法，属于对象
⭐对象.实例方法
## 十七.继承(extends)
让一个类与另一个类建立起父子关系。
#### 特点：
子类能继承父类的非私有成员（public:成员变量/方法）
## 十八.方法重写
当子类觉得父类中的某个方法不好用，或者无法满足自己的需求时，子类可以重写一个方法名称，参数列表一样的方法，去覆盖父类的这个方法。
重写后，方法的访问，java会遵循就近原则
⭐注意事项：
①使用@Override注解
②子类重写父类方法时，访问权限必须大于或等于父类该方法的权限
③重写方法的返回值类型，必须与被重写方法的返回值类型一样，或者范围更小
④私有方法，静态方法不能被重写
⭐常见应用常见
子类重写Object类的toString()方法，以便返回对象的内容
## 十九.final
#### ①修饰类：最终类，不能被继承了
#### ②修饰方法：最终方法，不能被重写了
#### ③修饰变量：该变量只能被赋值一次
## 二十.泛型
可以避免强制类型转换，及其可能出现的异常
本质：把具体的数据类型作为参数传给类型变量
```java
        // <String>：list里面只能放String类型的数据
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("java1");
        list1.add("java2");
        list1.add("java3");
        for (int i = 0; i < list1.size(); i++) {
        // 遍历出来的数据交给String
            String e = list1.get(i);
            System.out.println(e);
        }
```
⭐泛型不支持基本数据类型，只能支持引用数据类型