02.java基础（一）java的基础、方法和数组

目录

• Java基础
  • Java特性
  • Java程序运行机制
  • Java基础语法
    • 1.数据类型
      • 基本类型
      • 引用类型
      • 数据类型扩展
        • String类型内存分配过程
      • 转义字符
      • 类型转换
      • 变量
      • 常量
    • 2.运算符
      • 逻辑运算符、位运算符和关系运算符
        • instanceof的作用说明
      • 位运算符扩展
      • 三元运算符
    • 3. Javadoc生成帮助文档
• Java方法
  • 方法重载
    • 重载原则
  • 可变参数（不定向参数）
    • 使用事项
• Java数组
  • 内存分析
    • • 数组使用时的内存分配过程
  • 数组基本操作
    • 数组三种初始化
    • 数组的使用
    • Arrays工具类简析
      • 常用方法

Java基础

Java特性

1. 简单性-----没有头文件，没有指针，不用手动分配内存，语法基于C++
2. 面向对象---将编程重点放在对象和对象之间的接口上，模拟人的思维，万物皆对象
3. 可移植性---能够跨平台，忽略操作系统的差别，可以在很多操作系统上运行
4. 高性能-------Java有即时编译的功能，使部分代码编译速度接近C++，通过URL编写分布式程序
5. 动态性-------java本身不具有动态性，但是反射使得Java具有动态性
6. 多线程-------多线程的简单性也是Java成为主流语言的原因之一
7. 安全性-------java适用于网络的分布式环境，因此Java在安全性的目标投入很大精力，能够防病毒，防篡改，能够在运行前检查内存防止崩溃
8. 健壮性------有异常机制捕获异常

Java程序运行机制

​ Java同时具有编译型运行机制和解释型运行机制

1. 编译型

   速度快，把代码转换为存为机器码的可执行文件exe

2. 解释型

   速度慢，使用编译器把java文件生成class文件，加载到类加载器，再用字节码校验器验证代码正确性，通过后使用解释器解释成可在操作系统上执行的代码。

Java基础语法

### 1.注释

//  单行注释
/*
   多行注释
*/
/**
*   JavaDoc文档注释
*/

1.数据类型

强类型语言----变量使用符合定义的严格规定，变量要先定义才能使用，提高安全性，速度慢

String a = 10；//错误的
String b;
print(b);  //错误的
String c = "hello";  //正确的

弱类型语言----变量使用可以不符合定义规定（比如VBScript、JavaScript）

基本类型

1. byte---1字节
2. short---2字节
3. int---4字节
4. long---8字节
5. float---4字节
6. double---8字节
7. char---2字节
8. boolean---1比特

引用类型

非基本类型都是引用类型----类、接口、数组

数据类型扩展

public static void main(String[] args){

    //进制表示

    int i = 10;
    int i2 = 010; //八进制0
    int i3 = 0x10;  //十六进制  0-9 A-F

    //浮点数扩展   银行业务使用double和float有问题

    float f = 0.1f;
    double d = 1.0/10;
    //但是f！=d,有错误，浮点数是有限的，有舍入误差，千万不要用浮点数进行比较
     //但是f！=d,有错误，浮点数是有限的，有舍入误差，千万不要用浮点数进行比较
     //但是f！=d,有错误，浮点数是有限的，有舍入误差，千万不要用浮点数进行比较
    float f1 = 2323323266556655646464f;
    float f2 = f1 + 1;
    //但是f1=f2 ，有错误！！！！
    //但是f1=f2 ，有错误！！！！
    //但是f1=f2 ，有错误！！！！
    //要使用BigDecimal数学工具类    进行比较
  	//要使用BigDecimal数学工具类    进行比较
    //要使用BigDecimal数学工具类    进行比较
    /**

    BigDecimal("10086.11")的创建最好使用String字符串

    比较使用a.compareTo(b)对象方法
    返回值为int，有3种
    返回值为1  ====>  a>b
    返回值为0  ====>  a=b
    返回值为-1  ====>  a<b

    a+b  使用a.add(b)
    a-b  使用a.subtract(b)
    a*b  使用a.multiply(b)
    a/b  使用a.divide(b)
    如果除法结果出现无限不循环小数，程序会报错，使用a.divide(b,2)指定小数位即可
    **/

    //字符类扩展

    //强制转换把char类型转为int类型
    char a = 'a';

    int b = (int)a;
     //或者
    char c = '\u0061';

    //字符串常量池

    String a = new String("hello");
    String b = new String("hello");
    a!=b
    String a = "hello";
    String b = "hello";
    a=b

}

String类型内存分配过程

​ 1. String类型直接赋值

String key = "value";

​ key是引用类型，数据存放在栈中，数据内容是“value”在方法区的常量池中的地址，下一次其他变量引用时，地址不会改变

​ 2. String对象new创建

String key = new String("value");

​ key是引用类型，数据仍然存放在栈中，数据内容则是String类存放在堆中的地址，String类中的引用地址再指向“value”在方法区的常量池中的地址,下一次其他变量引用时，地址不会改变

转义字符

1. \t 制表符 多一个空格
2. \n 换行符 换行

​ 。。。

类型转换

低=================================>高

byte,short，char-> int -> long

float -> double

自动类型转换（低->高）

强制类型转换（高->低）

强制转换时，可能会出现内存溢出或者精度损失

JDK7新特性，数字可以用下划线分割

int money = 1_000_000;

变量

1. 类变量 static关键字(也有默认值不需要初始化)
2. 实例变量 每次类实例化一个对象时都产生的变量（数值类型默认值都是0、0.0、布尔值是false，引用类型默认值为null）
3. 局部变量 方法中定义的变量(需要初始化)

常量

final关键字：数值被初始化后不允许被修改（使用全大写和下划线定义常量名字）

static final double PI = 3.14;

2.运算符

逻辑运算符、位运算符和关系运算符

1. 逻辑运算符：||、&&、！
2. 位运算符：&、|、^(异或)、~、<<（数字左移变大*2，后尾补零）、>>（数字右移变小/2，开头补零）
3. 关系运算符： == ,>= ,<=, !=,instanceof

​ 在条件判断上，逻辑运算符运算部分逻辑结果时得出结果则跳过后面运算，但是位运算不会

instanceof的作用说明

instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例，但是不能用于判断基本类型。

​ 返回boolean类型

示例如下

boolean results = obj(对象名) instanceof Class(类名)

其中 obj 为一个对象，Class 表示一个类或者一个接口，当 obj 为 Class 的对象，或者是其直接或间接子类，或者是其接口的实现类，结果result 都返回 true，否则返回false。

​ 注意：编译器会检查 obj 是否能转换成右边的class类型，如果不能转换则直接报错；当不能确定类型，才会通过编译判断，具体看运行时定。

位运算符扩展

在计算2的5次方的时候，使用位运算的<<符号对计算机是计算最快的 2<<5

三元运算符

条件运算符的使用 ？：

示例如下

int a = 10;
int b = 20;
if(a > b ? true : false){
    sout("输出内容")
}
String type = a > b ? "first" : "second";

3. Javadoc生成帮助文档

使用命令行   javadoc -encoding UTF-8 -charset UTF 文件名
还能用IDEA生成

Java方法

方法重载

定义：一个类中，有相同的函数名称，但是形参不同

重载原则

1. 方法名称必须相同
2. 参数列表必须不同（个数不同，参数类型不同，或者不同的参数类型的顺序不同）
3. 方法的返回类型可以相同也可以不同
4. 仅仅返回类型不同不足以成为方法的重载

可变参数（不定向参数）

例子：

public static void printMax(double... numbers){

}
//调用
printMax(34,1,2,4,5);
printMax(new double[]{11,22,33});
//传递参数时只需要是double类型的参数都能传（数组或者任意个数的数。。。）

使用事项

1.可变参数要放在形参的最后一个

2.一个方法中只能有一个可变参数

3.可变参数是对象，它的本质就是数组

Java数组

内存分析

1. 堆

   存放new的对象和数组

   可以被所有的线程共享，不会存放别的对象引用

2. 栈

   存放基本变量类型（包括基本类型里的值）

   引用对象的变量，即对象的引用（存放引用在堆里面的地址）

3. 方法区

​ 可以被所有线程共享

​ 包含所有class和static变量（类变量和静态变量）

数组使用时的内存分配过程

​ 1.声明数组

int[] array = null;

​ 在栈中开辟一个引用地址给array，但此时没有数据，只有名称

​ 2.创建数组

array = new int[10];

​ 在堆中开辟十个连续的空间，把数组的首地址赋值给array

​ 3.给数组赋值

array[0] = 10;

​ 如果不给数组赋值，数组也会赋默认值

对应图解如下：

• 在栈中创建array引用，指向堆中新建的一片连续区域的数组地址，通过下标访问数组中每个元素，并且堆中int数组会被赋初始数字0

数组基本操作

数组三种初始化

1. 静态初始化

   import java.math.BigDecimal;
   
   //创建并给数组元素赋值
   int[] arrays = {1,2,34,5};
   BigDecimal[] b = {new BigDecimal("123"),new BigDecimal("456"),new BigDeciaml("111")};
   

2. 动态初始化

   int[] c = new int[10];
   b[0] = 5;
   

3. 数组的默认初始化

   • 动态初始化后没有赋值的元素会默认被赋予初始值

     1. byte、short、long、int类型赋予默认值0

     2. float、double类型赋予默认值0.0

     3. char类型赋予默认值'\u000'（空格）

     4. boolean类型赋予默认值false

     5. 引用类型赋予默认值null

数组的使用

1. 基本使用方法

   int[] arrs = {1,2,3,4};
   for(int i = 0; i < arrs.length; i++){
       sout(arrs[i]);
   }
   

2. for-each增强循环

int[] arrs = {1,2,3,4};
for(int arr : arrs){
    sout(arr);
}

1. 数组能作为方法参数或者返回值

public int[] copyArray(int[] a,int length){
    int[] copy = new int[length];
    copy = System.arraycopy(a,0,copy,0,Math.min(a.length,length));
    return copy;
}

1. 多维数组的使用

int[][] arrs = new int[8][6];// arrs = {{1,2},{3,4},{7,7}};
for(int i = 0; i < arrs.length; i++){
    for(int j = 0; j < arrs[i].length; j++){
        sout(arrs[i][j]+"\t");
    }
    sout("\n")
}

Arrays工具类简析

常用方法

打印数组

int[] a = {11,5,6,77,85,3};
System.out.println(a);   //打印a的HashCOde：[I@1b6d3586
System.out.println(Arrays.toString(a));    //打印数组元素：[11, 5, 6, 77, 85, 3]

数组排序

int[] a = {11,5,6,77,85,3};
Arrays.sort(a);   //进行排序，默认为递增
System.out.println(Arrays.toString(a)); //输出：[3, 5, 6, 11, 77, 85]

数组填充

int[] a = {11,5,6,77,85,3};
Arrays.fill(a,0,6,0);	//用0填充从a[0]到a[5]中的所有元素，Arrays.fill(数组，起始下标(包括该下标)，结束下标(不包括该下标)，填充元素值)
//Array.fill(a,0)   用0填充a数组每个元素
System.out.println(Arrays.toString(a));	//输出:[0, 0, 0, 0, 0, 0]

数组比较

Arrays.equals(int[] a, int[] b);

数组二分查找元素

Arrays.binarySearch(int[] a, int key);

看bilibili狂神说后的一些小白笔记与总结。边学习边成长。欢迎在文章下探讨~~

了解狂神说在以下链接：https://space.bilibili.com/95256449