Java初级必须掌握的知识大全

       1.计算机语言的发展史
              机器语言
              汇编语言
              高级语言
                     Java,C++,PHP
       2. 变量
              变量: 是一个容器,用来存储数据的
              语法:
                     1.声明的同时直接赋值
                           数据类型 变量名 = 值;
                           // 数据类型: String 字符串数据类型
                           // 变量名  : 自己取的名字
                           // =       : 赋值符号
                           // 值         : 数据
                           // ;        : 代表语句结束
                     例子:
                           String  name = "传智播客";// 定义一个变量
                                  /*
                                         String  数据类型  表示字符串的数据类型
                                         name   是变量名        自己取的名字
                                         =             赋值用的   把等于号右边的数据赋值给左边的变量
                                         ""            Java里面字符串就要用双引号引起来
                                         ;             代表语句结束
                                   */
                     2. 先声明后赋值
                           数据类型  变量名;  // 代表声明了一个变量
                           变量名 = 值;  //  把值赋给变量
                           String name;// 开辟了一块空间,空间的名字是name
                           name = "黑马程序员";// 赋值
                     注意:变量里面的数据是可以被覆盖的
              变量命名的规则:
                     1.只能由字母(a_zA_Z),数字(0-9),下划线(_),美元符号($)组成
                     2.不能以数字开头    1name 错误
                     3.不能与关键字重名   关键字就是系统保留的字,具有特殊含义
                     4.严格区分大小写    name  Name
              变量命名的规范:
                     知名达意   驼峰命名法    String myName;  如果变量名有多个单词,那么就从第二个单词开始所有单词的首字母大写
                                                               String my_name;
              常见的数据类型:
                     int           double        char          String        boolean(true\false)
                           
               数据类型:
                            1.常见的数据类型
                            2. 基本数据类型  4类8种
                            
                                   整数:
                                         byte
                                         short
                                         int                  整数直接写默认是int类型     正负21亿之间
                                         long
                                   
                                   小数:
                                         float   float类型的值必须加f\F,不加会报错
                                         double  小数直接写默认是double类型
                                   
                                   字符:
                                         char  字符类型的值必须要用单引号引起来,并且单引号只能有一个字符
                                   
                                   布尔:
                                         boolean (true\false)
                            
                            3. 引用数据类型    String 字符串
                            
               1KB = 1024字节;
               1MB = 1024KB;
               1GB = 1024MB;






       1.变量
              概述:就是一个容器,用于存储数据的
              语法:
                     1.声明的同时直接赋值
                           数据类型 变量名 = 值;
                           String name = "传智播o客";
                     2.先声明后赋值
                           声明: 数据类型 变量名;  String name;
                           赋值: 变量名 = 值;         name = "黑马程序员";
              标识符命名规则:
                     1.只能由字母,数字,下划线,美元符号组成
                     2.不能以数字开头
                     3.不能与关键字重名
                     4.严格区分大小写
              标识符命名规范:
                     知名达意
       2.运算符
              算术运算符: + -      *      /      %
                     注意:2个整数相除,得到的结果一定是整数
              比较运算符: >  >=  <  <=   ==     !=
                           // 比较表达式的结果一定是 boolean 类型的数据,所以比较表达式可以作为if结构的条件判断
              逻辑运算符:
              // 逻辑运算符的2边一定要是 boolean 类型的数据
              /*
                     && 逻辑与     只要有false,逻辑&&表达式的结果就是 false,只有当两边同时为true ,逻辑&&表达式的结果才是true
                                         遇 false ,则 false
                            
                     || 逻辑或     只要有true,逻辑||表达式的结果就是 true,只有当两边同时为 false,逻辑||表达式的结果才是 false;
                                         遇 true ,则 true
                                         
                     ! 逻辑非             真变假 假变真
                     
                     
                     &      遇 false 则 false
                     |      遇 true ,则 true     
               */
               && 短路的问题             只要逻辑&&的左边为 false ,逻辑&&的右边就不会运算
               || 短路的问题      只要逻辑||的左边为 true,逻辑||的右边就不会运算
              复合赋值运算符: =    +=     -=     *=     /=     %=
              自增\自减运算符:
                     ++            --
                     // 表达式的值        变量的值
              // 表达式 : 由运算符连接起来的式子就是表达式
              // ++ 运算符
              /*
                     num++ 后自增表达式:
                            运算法则:先取变量(num)自身的值作为表达式的值,然后将变量自身+1
                            
                     ++num 前自增表达式:
                            运算法则:先将变量自身的值+1,然后将变量的值作为表达式的值
                            
                            总结: 不管是前自增还是后自增,变量自身的值都得+1
                            
                 num-- 后自减表达式:
                            运算法则:先取变量(num)自身的值作为表达式的值,然后将变量自身-1
                            
                     --num 前自减表达式:
                            运算法则:先将变量自身的值-1,然后将变量的值作为表达式的值
                            
                            总结:不管是前自减还是后自减,变量自身的值都得-1
               */
              //            int num = 3;
                           //
              //            int res = ++num - num-- - ++num + num++ + ++num;
              //                            4/4       4/3            4/4    4/5        6/6
              //            int res = (++num) - (num--) - (++num) + (num++) + (++num);// 4-4-4+4+6
              //            System.out.println(res);//6
              //            System.out.println(num);//6
                           
              //            int num = 3;
              //            int res = num--;
              //            System.out.println(res);//3
              //            System.out.println(num);//2
                           
              //            int num = 3;
              //            int res = --num;
              //            System.out.println(res);//2
              //            System.out.println(num);//2
                           
              //            int num = 3;
              //            int res = ++num;
              //            System.out.println(res);//4
              //            System.out.println(num);//4
                           
              //            int num = 3;
              //            int res = num++;
              //            System.out.println(res);//3
              //            System.out.println(num);//4
       3.定义类\定义方法
              定义类的语法:
                     public class 类名{// 类名:符合标识符命名规则    从第一个单词开始所有单词的首字母大写
                           // 属性(变量)
                           // 方法(方法)
                           
                     }
              定义方法的语法:
                     public 返回值类型 方法名(数据类型 参数1,数据类型 参数2,...){
                           // 方法体
                           返回值: 根据方法的功能是否有返回值,如果方法没有返回值,返回值类型就是 void
                                         如果有返回值,返回值的数据类型就是方法的返回值类型,并且要有 return 语句
                           方法名: 自己取
                           参数: 用来传递数据的
                     }
                     注意:
                           1.方法和方法之间是平行关系
                           2.方法不调用不会执行
       4. 选择结构
              
       补充:
              // 成员变量: 定义在类里面,方法的外面的变量,系统会自动赋默认值
              // 局部变量: 定义在方法里面的变量,系统不会赋默认值
              // 变量没有赋值是不能直接使用的
              常用的数据类型                    初始值
                     
                     int                               0
       
                     float                      0.0
                     double                     0.0
                     char                       空(0)
                     String                     null
                     boolean                           false


       
       3.运算符:
              算术运算符: + - * / %(取模\取余数)
                     注意: 2个整数相除,得到的结果一定是整数(取整数部分)
              比较运算符:
              逻辑运算符:
              赋值运算符: =
       
       4.程序的结构
              顺序结构
              分支\选择结构
                     1.
                           if(条件语句){
                                  // 任意的代码    条件成立,就会执行,条件不成立,就不会执行
                           }
                           
                     2.
                           if(条件){
                                  // 条件成立,就会执行的代码 1
                           }else{
                                  // 条件不成立,就会执行的代码 2
                           }
                           // 所以代码1 和代码2 不会同时执行,也不会同时不执行
                     3.
                           if(条件1){
                                  // 代码1
                           }else if(条件2){
                                  // 代码2
                           }else if(条件3){
                                  // 代码3
                           }else{
                                  // 代码4
                           }
              循环结构:
       5.注释
              //     注释: 大白话就是用来解释代码的,给程序员看的,不参与程序的运行
              //     分类:
              //            单行注释                   //     添加\取消单行注释快捷键  ctrl + / 
              //            多行注释  
                                         /*
                                                       多行注释        
                                                       注意: 多行注释不能嵌套多行注释
                                          */
              //            文档注释
                                  /**
                                         文档注释  主要用于注释类\方法
                                   */
       6.定义类和方法
               如何写类
                     概念: 就是一群具有相同特征和行为的事物的统称
                     语法:
                           权限修饰符 class 类名{
                                  // 类的特征\属性
                                  // 类的行为\方法
                           }
                           
                           权限修饰符: public
                           类名: 自己取的名字    符合标识符命名规则和规范        类名是从第一个单词开始每个单词的首字母大写
                           
              如何写方法
                     简单的方法: 无参数无返回值的方法
                     语法:
                           权限修饰符 返回值类型 方法名(数据类型 参数名1,数据类型 参数名2,....){
                           
                                  // 方法体\功能代码
                           }
                           
                           权限修饰符: public
                           返回值类型: 无返回值  void
                                                有返回值  返回的数据是什么数据类型那么返回值类型就是什么数据类型
                           方法名: 自己取  符合标识符命名规则和规范     方法名是从第二个单词开始每个单词的首字母大写
                           参数: 用来传递数据的     如果不需要外界传数据 那就空着
                           方法体: 功能代码\执行的代码
                           
                           注意: 方法不调用不会执行
                           
                     调用方法:
                           方法名(实际参数);  // 实际参数: 具体的值
              
                     
       1. 自己定义的方法
              1.明确方法的返回值类型    ---> 有返回值         ---> 整数int
              2.明确方法名                      -->  自己定义     ---> add
              3.明确方法的参数                  ---> 2个参数  都是 int 类型
              4.明确方法的功能
       
       2. 调用别人的方法
              1.明确方法的功能
              2.明确方法的方法名
              3.明确方法的参数
              4.明确方法的返回值
       
       // add()  加法    ---->  计算2个整数之和
        10 + 30
        40 - 2
       
        调用方法的语法:
              方法名(实际参数);
       知识点补充:
              1.java语言是严格区分大小写
              2.面向过程:按照步骤一步一步执行
              3.面向对象:找专业的人做专业的事情
              4.字符串的相加: 其实就是拼接
              // 补充: 任何数据类型的数据和字符串相加,就会拼接成一个新的字符串
              System.out.println(5+"heima");//5heima   alt + /
              System.out.println(5+5+"heima");//10hiema
              System.out.println("heima"+5);// heima5
              System.out.println("heima"+5+5);//hiema55
              // 引用数据类型: String 
              // 1.隐式类型转换   把小范围的数据 赋值给 大范围的变量  会自动转换
              double d = 14;
              
              // 2.强制类型转换   把大范围的数据  赋值给 小范围的变量
              int  num = (int)1.73;




面向对象与面向过程
     面向过程: 第一步做什么，第二步，第三步做什么
     面向对象：调用对象的方法做事情


万物皆对象


在Java语言中，我们通过类创建对象
     属性：事物体现的外在特征，名词           ==>  成员变量
     行为：事物能够做什么， 动词               ==>  成员方法


通过Java语言去描述事物
     1.定义类
          定义成员变量
          定义成员方法
     2.使用这个类创建对象
          创建对象，调用对象的属性和行为
         
类与对象
     类：具有一组相关属性和行为的集合, 模版，图纸
     对象：该类事物的具体体现，具体的产品
    
封装
     把对象的属性和访问细节给隐藏起来, 仅对外提供公共的访问方式
          1. 不能让别人直接访问我的成员变量 --> 通过private关键字
          2. 提供公共的访问方式 --> 通过set方法赋值, 通过get方法取值
    
     变量访问的原则: 就近原则. 也就是说, 局部位置有, 就使用局部变量. 局部位置没有, 才去找成员变量.
    
this
     代表当前的这个对象
     用来解决局部变量与成员变量的重名问题
    
    
构造方法
     构造方法有且仅有一个作用, 那就是用来创建对象
     当我们没有写构造方法时, 系统会为我们默认提供一个无参构造. 当我们写了构造方法时, 系统就不会再给我们提供默认的无参构造了
     构造方法的格式
          public 类名(xxx){
              
          }
          注意:
               方法名与类名一致,连大小写也要一样
               构造方法没有返回值类型, 连void也没有


     有参构造与带参构造的区别
          共同点: 无论是有参构造还是无参构造, 都创建出了对象
          区别: 带参构造在创建对象的同时, 为属性进行了赋值
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    数组的两种定义方式
     静态初始化方式: String[] names = {"A","B","C","D","E"};
     动态初始化方式: String[] names = new String[5];


数组的索引
     数组在内存中是连续的, 所以我们可以通过索引去找到对应位置的元素. 在Java语言中我们规定，数组的索引是从0开始的.


获取数组中的元素
     根据索引获取对应位置上的元素: 数组名[索引]


数组的长度
     数组名.length
    
数组中的最大索引，最后一个元素对应的索引
     数组的长度-1




     1. static ---> 静态的意思
          修饰成员变量:  ----> 静态成员变量
               1. 资源共享,被static修饰的成员变量会被该类下的所有对象共享,也就是说所有对象使用的是同一份数据
               2. 可以用类名.属性名去访问
         
          修饰成员方法:  ---> 静态方法
               1. 位置: 返回值类型之前
               2. 可以用类名.方法名调用方法(不用创建对象了)
              
               注意:
                    1. 静态方法里面不可以有this
                    2. 静态方法里面只能直接使用静态(静态成员变量\静态成员方法)




     2. 包:
          概述: 文件夹


          导包: ctrl + shift + o


          // java.lang  这个包下的类是不需要导包的,其他的都需要导包




     3. 工具类：
          是一个概念，一般工具类的文件名为    功能名称+Utils
    
          工具类里面的方法一般都是静态方法，也就是被static修饰的方法


     4. final 终态
          final 关键字一旦修饰了变量，这个变量就变成了常量,无法再次被修改了


          修饰成员变量:成员变量用了final 修饰就会变成常量 常量是不能更改的
                         final 修饰成员变量,只能在定义的时候赋值,并且只能赋值一次


                         工具类里面的属性: 一般的修饰符是:  public static final


          局部变量:修饰局部变量 变成常量,而常量只能赋值一次




     5. RPG游戏
    
          特点:
               0. 交谈: 玩家和电脑人交谈,电脑人会回答玩家 ,玩家不主动跟电脑人交谈,电脑人不会跟玩家交谈
               1. 回合制游戏   玩家攻击电脑人,电脑人受伤(掉血),电脑人反击玩家,玩家受伤(掉血)


               2. 玩家不攻击电脑人,电脑人是不会攻击玩家的
               3. 如果没有攻击到,也就是说避开了,就不会掉血
               4. 血量为0之后,就会退出游戏




          类: 类名  属性  方法
               玩家类:
                    属性: 姓名     血量
                   
                    方法:
                         1. 跟电脑人交谈的方法
                         2. 攻击电脑人
                         3. 受伤的方法






               电脑人:
                    属性: 姓名     血量
                    方法:
                         1. 回答玩家
                         2. 受伤的方法
                         3. 反击玩家




               游戏界面类:  测试类
         
     1.循环
          概述: 一件事情反复不停的做就叫做循环


          A:循环结构的分类
          ????* for,while,do...while?


          1) while 循环
               语法:
                    初始化语句;
               ?????while(判断条件语句) {
               ????????????循环体语句;
               ????????????控制条件语句;
               ??????}


             ?B:执行流程：
               ????* a:执行初始化语句
               ????* b:执行判断条件语句,看其返回值是true还是false
               ????????* 如果是true，就继续执行
               ????????* 如果是false，就结束循环
               ????* c:执行循环体语句;
               ????* d:执行控制条件语句
               ????* e:回到B继续。




          例子:
                    int i = 0; ①            //初始化条件
                    while(i < 10) { ②  //判断条件
                         System.out.println(i); ④     //循环体
                         i++;③          //控制条件
                    }
               执行顺序:
                    第一次:  ①,  ②, ④, ③
                    第二次:  ②, ④, ③
                    第三次:  ②, ④, ③
                    ......
                    最后一次:  ②  //条件满足就执行循环体,不满足就结束循环
                    //判断条件永远比 控制条件多执行一次.




          练习:
               简单版:
                    使用while循环,打印10次我要来黑马学习


               进阶版:
                    让用户输入密码88888,如果输入错误就重新输入,直到输入正确为止


                    请打印 1-100 之间可以被 8 整除的数




          2) do...while     循环


               语句的格式：
          ????????do {
          ????????????循环体语句;
          ????????}while(判断条件语句);
          ????????
          ????????
               完整格式；
          ????????初始化语句;
          ????????do {
          ????????????循环体语句;
          ????????????控制条件语句;
          ????????}while(判断条件语句);


               ?B:执行流程：
               ????* a:执行初始化语句
               ????* b:执行循环体语句;
               ????* c:执行控制条件语句
               ????* d:执行判断条件语句,看其返回值是true还是false
               ????????* 如果是true，就继续执行
               ????????* 如果是false，就结束循环
               ????* e:回到b继续。


               例子:
                    int i = 0; ①            //初始化条件
                    do{ ②  //判断条件
                         System.out.println(i); ④     //循环体
                         i++;③          //控制条件
                    }while(i < 10)




          3) for 循环


               ?B:循环结构for语句的格式：


          ????????for(初始化表达式;条件表达式;循环后的操作表达式) {
          ????????????循环体;
          ????????}


               ?C执行流程：
               ????* a:执行初始化语句
               ????* b:执行判断条件语句,看其返回值是true还是false
               ????????* 如果是true，就继续执行
               ????????* 如果是false，就结束循环
               ????* c:执行循环体语句;
               ????* d:执行循环后的操作表达式
               ????* e:回到B继续。


               例子:
                         ①      ②    ③
                    for(int i=0; i<10; i++) {     //这个循环的作用是: 打印0-9之间的数字
                         ④
                         System.out.println(i);     //这是循环体
                    }
                    执行顺序:
                         第一次:  ①,  ②, ④, ③
                         第二次:  ②, ④, ③
                         第三次:  ②, ④, ③
                         ......
                         最后一次:  ②  //条件满足就执行循环体,不满足就结束循环




          4) 增强for循环


               格式:
                    for(数据类型 变量名 : 要遍历的集合或者数组) {
                         //正常的功能代码
                    }




          双重for循环
               // 外层循环控制行,内层循环控制列
               // 外层循环一次,内层循环所有次




          正则:
               *?需求:?
          ?????* 定义一个工具类RegexUtils, 在该类中定义一个方法checkPhoneNumber(Strnig phone);
          ?????* 用来校验指定的字符串是否是合法的手机号.
          ?????* 手机号规则:
          ?????????* 1.长度必须是11位.
          ?????????* 2.必须是纯数字
          ?????????* 3.必须是数字1开头的.
          ?????????* 4.第二位数字必须是3,4,5,7,8






     1.HashMap:










     2.ArrayList:






     分类: 此处先写三个循环    




               普通for循环:
                    格式:
                                ①      ②    ③
                         for(循环初始语句;循环条件语句 ;改变控制循环变量语句 ) {     //这个循环的作用是: 打印0-9之间的数字
                              ④
                              System.out.println(i);     //这是循环体
                         }


                                ①      ②    ③
                         for(int i=0; i<次数; i++) {     //这个循环的作用是: 打印0-9之间的数字
                              ④
                              System.out.println(i);     //这是循环体
                         }


                    执行顺序:
                         第一次:  ①,  ②, ④, ③
                         第二次:  ②, ④, ③
                         第三次:  ②, ④, ③
                         ......
                         最后一次:  ②  //条件满足就执行循环体,不满足就结束循环


               增强for循环;
                    for(数据类型 变量名 : 要遍历的集合或者数组) {


                         //正常的功能代码


                    }




               集合的遍历:
                    HashMap集合的遍历:
                              // 增强for循环
                              // 1.获取所有键的集合   单列集合
                              // 2.遍历所有键的集合  获取每一个键
                              // 3.根据获取到的键去取值
     1.继承
          概述:在开发中,我们发现多个类具有很多相似的功能,于是我们就把这些相似的功能放到一个类中,然后让这多个类和这个类产生一个关系,
               这个关系就叫做继承


          关键字: extends


          语法:
               public class A类 extends B类{
               }


          认识:
               A类: 子类,派生类


               B类: 父类,基类,超类




          特点:
               1.子类继承父类,只能单继承,不能多继承,但是可以多层继承
               2.子类继承父类,就拥有父类里面的非私有属性\方法


          继承中成员变量的访问特点:
               使用变量遵循"就近原则", 先在局部位置找, 有就使用, 没有就去本类的成员位置找,?
????          ?* 有就使用, 没有就去父类的成员位置找,有就使用, 没有就报错.


          注意事项:
               * 1.子类继承父类,不能继承父类的私有属性和私有方法
               * 2.子类继承父类,不能继承父类的构造方法,但是可以使用
               *           关键字: super
               *           调用父类的空参构造方法: super();
               *           调用父类的有参构造方法: super(参数);
               *
               *           直接调用父类的普通方法; super.方法名();
               *           直接访问父类的属性: super.属性名
               * 3.不要为了继承而继承
               *           Dog 属性:姓名     年龄
               *                方法: 吃东西
               *
               *           Person 属性: 姓名  年龄
               *                     方法: 吃东西
               *
               *           程序员:
               *                属性: 姓名  工号        薪资
               *                方法; 写代码
               *          
               *           项目经理:
               *                属性:姓名     工号     薪资     奖金
               *                方法: 写代码 审计代码
               * 4. 满足 is a 的关系
               *           学生 属于 人类
               *           子类  属于  父类
         
          方法的重写:
               概述: 子类出现和父类一模一样的方法


               为什么要重写方法?
                    1.父类的功能无法满足子类的需求
                    2.当子类具有特有的功能的时候




               重写的注意事项:
                    1.父类的私有方法不能重写
                    2.子类重写父类的方法,重写的方法的访问权限不能低于父类的访问权限
                         private(本类) < protected(同一个包) < 默认(本类和子类) <  public(当前项目中)


                    3.静态方法严格意义上来讲不是方法的重写(只是表现形式和方法的重写意义)
                        


          方法的重载:
               概述: 方法名一致,方法的参数不一致(参数的数据类型不一致,参数的个数不一致)




          final 关键字
               1.修饰类
                    被final修饰的类不能被子类继承


               2. 修饰方法
                    被fianl修饰的方法不能被子类重写


               3. 修饰变量
                    被final修饰的变量会变成一个常量,常量只能赋值一次


     2. 多态
          多态指的是: 同一种行为,对于不同的事物具有不同的表现形式。 这就叫做多态。
               医生               咔               动手术
                   
               理发师               咔               剪头发


               演员               咔               停止了


          程序中的多态:不同的对象  以 自己的方式响应    相同名称方法的能力称为多态


               Dog                    吃                    吃骨头


               Cat                    吃                    鱼


               Monkey               吃                    香蕉


          多态的条件:
               1. 继承
               2. 方法的重写
               3. 父类的引用指向子类的对象


         
          多态的使用\好处:
               1. 开发中使用父类的类型作为方法的参数类型声明，那么以后不管传入任意的子类对象,都可以接收。
               2.在调用方法的时候，调用的是子类的方法，前提是父类必须要有该方法，不然会编译不通过。


          多态成员访问特点:
               多态的成员访问特点:
                    成员变量: 编译看左边,运行看左边
                    成员方法:
                         静态方法: 编译看左边,运行看左边
                         非静态方法: 编译看左边,运行看右边
               总结: 除了非静态方法是编译看左边,运行看右边,其他情况都是编译看左边,运行看左边




          向下转型:
               Animal anl = new Dog();// 向上转型
               Dog dog = (Dog)animal;// 向下转型
               dog.lookHome();






     3.抽象类:
          抽象方法: 没有方法体的方法就是抽象方法 一般用 abstract
          抽象类: 用 abstract修饰的类就是抽象类, 有抽象方法的类一定是抽象类
         
          特点:
               1.有抽象方法的类一定是抽象类
               2.不能创建对象,通过其子类来创建对象
               3.可以有构造方法,但是不能用来创建对象,
                         用于子类对象访问父类数据之前,对父类的属性初始化
               3.子类:
                    普通类: 必须要实现父类的抽象方法
                    抽象类: 不一定要实现父类的抽象方法




     4.接口:
          概述:用 Interface 定义的就是接口


          实现:
              
               public class 类A implements  接口{
               }


               public class 类A extends 类B implements  接口{
               }


          特点:
               1. 定义接口 使用的关键字是 Interface


               2. 实现接口 使用的关键字是 implements


               3. 不能有构造方法,也不能创建对象,通过实现类来创建对象


               4. 实现类:
                    普通类: 一定要实现接口中的抽象方法


                    抽象类: 不一定要实现接口中的抽象方法




          成员特点:


               JDK1.7及以前的:
                    成员变量: 默认修饰符 public static final


                    成员方法: 只能是抽象方法  默认修饰符 public abstract




               JDK1.8:
                   
                    成员变量:默认修饰符 public static final
                   
                    成员方法: 增加了有方法体的方法,非静态方法,需要加 default 修饰,静态方法就直接写




          接口:
         
          类:




          类和类的关系:


          类和接口的关系:


          接口和接口的关系:


          接口和抽象类的区别: