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

Java基础

Java特性

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

Java程序运行机制

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

编译型

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

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

Java基础语法

 ### 1.注释

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

1.数据类型

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

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

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

基本类型

byte---1字节
short---2字节
int---4字节
long---8字节
float---4字节
double---8字节
char---2字节
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”在方法区的常量池中的地址,下一次其他变量引用时，地址不会改变

转义字符

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

。。。

类型转换

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

byte,short，char-> int -> long

float -> double

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

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

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

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

 int money = 1_000_000;

变量

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

常量

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

 static final double PI = 3.14;

2.运算符

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

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

方法重载

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

重载原则

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

可变参数（不定向参数）

例子：

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

使用事项

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

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

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

Java数组

内存分析

堆

存放new的对象和数组

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

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

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

可以被所有线程共享

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

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

1.声明数组

 int[] array = null;

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

2.创建数组

 array = new int[10];

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

3.给数组赋值

 array[0] = 10;

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

对应图解如下：

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

数组内存图

数组基本操作

数组三种初始化

静态初始化

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

动态初始化
```
 int[] c = new int[10];
b[0] = 5;
```
数组的默认初始化
- 动态初始化后没有赋值的元素会默认被赋予初始值
  1. byte、short、long、int类型赋予默认值0
  2. float、double类型赋予默认值0.0
  3. char类型赋予默认值'\u000'（空格）
  4. boolean类型赋予默认值false
  5. 引用类型赋予默认值null

数组的使用

基本使用方法

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

for-each增强循环

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

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

 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;
}

多维数组的使用

 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

posted @ 2023-02-08 22:38 嬉嘘aʊ 阅读(30) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 01Java常用类

· 03java基础（二）java面向对象

· Java基础学习笔记

· 狂神说Javase学习2

· java基础（数组、面向抽象编程、static、异常）

公告

昵称：嬉嘘aʊ
园龄： 3年
粉丝： 0
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

随笔分类

随笔档案

2023年2月(3)

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

	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

	}

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

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

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

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

	import java.math.BigDecimal;

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

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

	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;
	}

	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")
	}

	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]

XiaoCk`BlogSᒼᙆ

学习中~