Java基础学习

1、Java组成

        JRE（Java运行环境） = JVM + 核心类库

        开发工具 = javac（编译工具）  +  java （执行工具）

        JDK（Java开发工具包） = JRE + 开发工具

2、Java基础语法

2.1 注释

        注释是写给开发人员的语言，用于记录开发流程或者开发思路，便于后期维护

2.2 关键字和标识符

2.2.1 概念

        关键字：关键字是被Java使用，在其中被赋予了特殊功能的字字符

        标识符：开发人员在程序开发中自定义的字符

 2.2.2 标识符组成部分

        标识符由下划线（_）、数字、字母、$组成，其中数字不能作为开头第一个字符，且Java严格区分字符大小写，同一字符大小写不同，代表的名称也不一样。推荐使用小驼峰命名法。

2.3 数据格式

        在计算机语言中，只存在二进制，也就是0和1。在底层，计算机是按字节（byte）来读取数据的，一个字节是8位二进制。而人类语言中普遍使用十进制，为了方便人类阅读，故而引入了八进制和十六进制的概念。八位二进制是3个二进制为一组，十六进制是4个二进制为一组。

2.4 数据类型

        数据类型分基本数据类型和引用数据类型，基本数据类型为4大类8种，为了大家能方便理解，故使用图片进行展示

2.4.1 类型转换

        在基本数据类型中，byte和boolean占1个字节，short和char占2个字节，int和float占4个字节，long和doule占8个字节。

        在java中，不同类型的数据相互可以进行转换，其中由小字节数据向大字节数据转换称为自动类型转换，由大字节数据向小字节数据转换称为强制类型转换。

        自动类型转换有2条路线:

        byte -> short -> int -> long -> float  -> double

        char -> int -> long -> float -> double

        在自动类型转换中，要注意，遇到byte、short、char参与的运算，结果会自动转换成int，在表达式中，运算结果的数据类型以参与表达式的数据类型中字节数大的为准。

        强制类型转换要注意精度丢失的问题，且要在字符前加上要转换成的数据类型，格式为：目标数据类型 变量名 = （目标i数据名）要转换的数据

2.5 运算符

2.5.1 算术运算符

        

        注意事项：

        1、在int类型中，int类型的数据相除，结果仍然是int类型，如果有小数部分，小数部分会丢失

        2、用+在进行字符串拼接时，+前如果是字符串，则会进行拼接，+前如果是数字，则会进行相加运算

2.5.2 自增自减运算符

        

        需要注意的是，如果对变量自增自减不是一句单独的语句，而是在表达式中，要知道符号在前，是先进行自增自减运算再做其他运算，如果符号在后，则是先做其他运算后，才进行自增自减。

2.5.3 赋值运算符

        需要注意赋值运算符的底层有强制类型转换，要注意精度丢失的问题！

2.5.4 关系运算符

2.5.5 逻辑运算符

2.5.6 三元运算符

        格式：数据类型 变量名 = 条件表达式 ? 值1 ： 值2

//如
    String result = 100>80 ? "真" ："假" ;

2.6 流程控制

        概念：控制我们的代码按照什么结构顺序来运行。

        主要有三种结构：顺序结构（默认）、循环结构、分支结构

2.6.1 顺序结构

        顺序结构就像一条直道，只能按照从开始到结束走，不能回头，没有岔路。程序默认按顺序结构执行。

2.6.2 循环结构

        循环结构像一个圆，不断在里面绕圈，只有达到一定的条件才可以出去。

        作用：控制一段代码重复执行。

//循环结构
//语法一： 
    do{
        执行语句;
        迭代语句;
    }while(循环条件);

//语法二:
    for(初始条件;循环条件;迭代语句){
        执行语句;
    }

//语法三：
    while(循环条件){
        执行语句;
        迭代语句;
    }

        

2.6.2.1 循环嵌套 

        概念：循环里面再套循环

        执行流程：外面的循环执行一次，里面的循环执行一遍，即里面的循环要跳出才能执行一次外面的循环。

2.6.2.2 死循环

        概念：循环判断语句一直为Ture，在无外力干预的情况下会一直执行循环语句

2.6.2.3 终止关键字

        continue：终止当次循环，从下一次循环开始。

        break：跳出循环。

2.6.3 分支结构

        分支结构就像是一条路上出现的岔路，可以通过岔路到达不同的地方。

2.6.3.1 分支结构之if

// if分支语句
//语法一：
  if(条件判断){
  }
//语法二：
   if(条件判断){
   
   }else if(条件判断){
        
   }else{
   
   } 

//语法三：
    if(条件判断){
    
    }else{

    } 

2.6.3.2 分支结构之switch

         注意：
            1、表达式类型只能是byte、short、int、char，JDK5开始支持枚举，JDK7开始支持String、不支持double、float、long。
            2、case给出的值不允许重复，且只能是固定的值，不能是变量。
            3、正常使用switch的时候，不要忘记写break，否则会出现穿透现象。

//switch分支
//语法
   switch(表达式){
        case 值1:
            执行代码;
            break;
        case 值2:
            执行代码;
            break;
        default:
            执行代码;
        
    }

 2.7 数组

        概念：相当于一个容器，可以装相同类型的数据

2.7.1 数组的使用

        1、静态初始化

               格式：
                    数据类型[] 数组名 = new 数据类型[] {元素1,元素2...}
                    数据类型[] 数组名 = {元素1，元素2...}
             数组的访问
                    获取数组的数据  数组名[索引值]
             数组的长度
                    数组名.length
             数组的索引最大值
                    数组的长度 - 1
             注意事项
                  · 数组索引从0开始
                  · 获取数据超过索引最大值会报索引越界异常
                  · 数组如果为null的话是不能再使用数组的长度和获取数据

         2、动态初始化       

               格式：
                     数据类型[] 数组名 = new 数据类型[长度]       

2.7.2 数组的原理 

2.7.2.1 数组的存储

        在堆中开辟一片连续的内存，用来存储数据，这一片地址的大小从创建之初就已经固定，无法改变。然后把这片内存的第一个地址，保存到数组名所指向的栈内存中。也就是说，数组名所访问到的，是一个地址值，这个地址，是真正开辟出来用来存储数据的那一片内存的第一个地址的地址值。

2.7.2.2 数组的初始化

         如果使用静态初始化，那么数组中的数据默认值就是传入的数据值。如果使用动态初始化，则相当于创建了一个对象，而作为一个对象，初始化时则必有初始值，如果没有赋值，则系统会自动给一个默认值。如果是基本数据类型，默认值如下：
           整型：      0
           浮点型      0.0
           波尔型      false
           字符串型  null
如果是引用数据类型，则默认是Null。

2.8 方法

概念：被封装起来，用于实现某种功能的代码

作用：提高代码复用性，提高开发效率

定义：

修饰符 返回值 方法名（形参）{
    方法体;
}

注意事项：

1、有返回值的方法可以被接收，也可以调用之后不接收

2、无返回值的方法，不可以在输出语句中使用

方法的重载与重写

        重载：重载体现了多态的思想，指在一个类中定义多个同名方法，它们或有不同的参数数目，或有不同的参数类型。重载是编译时重载。

        重写：重写体现了多态的思想，指子类对父类方法进行重写，以达到不同的效果。重写是运行时多态。

3、面向对象

概念：一种编程方法，对世界的抽象

面向对象的三大特征：封装、继承、多态

执行原理：在堆内存中开辟一个空间，初始化对象的变量值，对象名保存的是一个地址，指向堆内存的对象。

注意事项：

1、类名建议使用驼峰命名

2、成员变量在初始化的时候有默认值

成员变量和局部变量

        成员变量：类中方法外

        局部变量：类中方法内

        区别

3.1 类

类：类是对象的抽象，对象是类的实例

this关键字：获取调用者的对象

static关键字：表示在内存中只存在一个

final关键字：修饰类，类不能被继承；修饰方法；方法不能被重载；修饰如果修饰的是基本数据类型，那么值不能改如果修饰的是引用数据类型，那么地址值不能改

3.1.1 类的五大成员

  3.1.1.1 构造器

   作用：初始化对象

   语法：

修饰符 类名(形参){
    方法体;
}

注意事项：

1、类在创建的时候会默认提供一个无参的构造器

2、定义了有参构造器之后，默认的无参构造器不再自动提供，需要显式的编写无参构造器    

   3.1.1.2 成员变量

概念：对象的属性

3.1.1.3  成员方法

概念：对象的行为，代表一个独立的功能

3.1.1.4代码块

实例代码块：用于初始化实例资源，在每次调用构造器时调用

静态代码块：用于初始化静态资源，在类加载时调用

3.1.1.5内部类：

概念：在一个类中的类叫做内部类。把外部的类叫做外部类

分类：

1、成员内部类：在外部类的里面，在外部类的方法的外面。

    静态成员内部类：有static修饰

    非静态成员内部类：没有static修饰

2、 局部内部类：在外部类的方法体里面。
    有名局部内部类
    匿名局部内部类

3、匿名内部类：没有名字的类， 通常用在方法参数中，用于创建一个对象

        格式：

new 父类/接口() {
   重写方法;
}

3.2 抽象类

      概念：使用abstract定义的类，用于对类抽象

       特点：

        1、抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
        2、抽象类可以写普通的所有内容，还多抽象方法
        3、抽象类不能创建对象
        4、子类继承抽象类，一定要重写里面所有的抽象方法，否则，当前子类也要定义为抽象类

        格式

修饰符 abstract 类名{
    
}