java笔记(基础篇)_在一个实例变量前面加上-CSDN博客

本文链接：https://blog.csdn.net/baimeng__1027/article/details/114190109

注释

一定要经常写注释！！！！！、

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

标识符

java所有组成部分都需要名字。类名，变量名以及方法名都被称为标识符。

标识符都应该以字母，美元符（$），或者下划线（_）开始
首字符之后可以字母，美元符（$），或者下划线（_）加数字的组合
不能使用关键字作为变量名或方法名

数据类型

java的所有变量都必须先定义后才能使用

`java`的数据类型分为两大类

引用类型

类，接口，数组

基本类型

整数类型

byte占1个字节：-128-127

short占2个字节：-32768-32767

int占4个字节：-2147483648-2147483647最常用

long占8个字节：-9223372036854775808-9223372036854775807后面要加大写L
浮点类型

float占4个字节后面要加大写F

double占8个字节
字符类型

char占2个字节

字符串String不是关键字，是类
boolean类型：占1位其值只有true和false两个

1 B（byte，字节）= 8 bit位

拓展

进制

二进制 0b

0b101 = 5
八进制0

045 = 13
十六进制 0x

0x1a = 26

浮点数

0.1 != 1.0/10

最好完全避免使用浮点数进行比较

常用转义字符

\n 表示换行。

\t 水平制表符，相当于Table键

\ ’ 单引号

\’’ 双引号

\u Unicode编码

类型转换

不同数据类型转化为同一类型，然后进行运算。

低--------------------------------------------------------------------->高

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

低转高自动转换

高转低强转会内存溢出，数据丢失

数字之间可以用下划线分割 -----> 10_0000_0000

强转

（数据类型）变量或数值 ----> (int)a

变量

数据类型变量名 = 数值；-----> int a = 10;

作用域

局部变量

局部变量在方法里面有效期在方法里面，必须声明和初始化值。

实例变量

从属于对象在类里面方法外边，不需要初始化值也可以使用但是需要声明。

下面是使用方法：

**变量类型变量名字 = new 类名字(); **

Student student = new Student();

student.变量

如果没有初始化数值变量默认为0，0.0。布尔值默认为false。其他的类型为null。

类变量

在实例变量前面加上static就变成类变量了，类变量在类里面可以直接调用。

常量

常量在初始化后就不能再改变！

final 常量名 = 值；-----> final double PI = 3.14;

一般来说常量名使用大写字符。

运算符

加减乘除±*/

除余% ----> 12%5 == 2

自增自减++ –

a++是先赋值再自增，++a是先自增再赋值。

a=10; b = a++; b == 10;

a=10; b = ++a; b == 11;

赋值 = ------> a = 10;

大于，小于，大于等于，小于等于 >，<，>=，<=

等于，不等于 ==，!=

与或非 &&，||，!

a+=1 == a=a+1

位运算符：&，|，^，~，>>，<<，>>>

A = 0011 1100
B = 0000 1101
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~B = 1111 0010

三元运算符：x ? y : z -----> 如果x == true，则结果为y，否则结果为z。

Scanner对象

Scanner scanner = new Scanner(System.in);

scanner.close();

使用scanner一定要用完关闭不然会一直占用资源

接收数据

scnner.next();

next不能得到带有空格的字符串,有效字符后的空格后面的不会读取到

scnner.nextLine();

可以获得空白

scnner.next+类型();

获得指定类型

scnner.hasNext+类型();

如果输入类型相符为true否则为float

结构

顺序结构

从上到下依此执行

单if选择结构

a.equals(b)判断字符串a,b是否相等

if(布尔表达式){如果表达式为真则执行，反之跳过}

双if选择结构

if(布尔表达式){

如果表达式为真则执行

}else{

如果为假执行

}

if多选择结构

if(布尔表达式1){

如果表达式1为真则执行

}else if(布尔表达式2){

如果表达式2为真则执行

}else if(布尔表达式3){

如果表达式3为真则执行

}else{

如果都不为真执行

}

switch多选择结构

switch(变量){

case 数值1:

如果变量与数值1相等想要执行的操作

break;

case 数值2:

如果变量与数值2相等想要执行的操作

break;

default:

如果变量与所有数值都不相等想要执行的操作

}

其中case的数量不限，break可选（没有break会有数值穿透），default可选

while循环

while(布尔表达式){

如果表达式为真时想要执行的程序

}如果表达式一直为真，循环就会一直执行。

do while 循环

do{

代码

}while(布尔表达式);

do while 循环会至少循环一次。while是先判断后执行，do while 是先执行后判断。

For循环

for(初始化;布尔表达式;更新){

执行的程序

}

for(int i = 0;i < 10;i++){

}在循环里i值随着循环次数而变化

增强for循环

for(声明语句 : 表达式)

{

执行的程序

}

声明新的局部变量，作用于限定在循环语句块，类型必须和数组元素相匹配。

表达式是你想要访问的数组名

for(int x : numbers){

}

break continue

break在循环中用于终止循环，不再执行剩下的程序。

continue在循环中用于终止某一次的循环，跳过这次循环要执行程序直接执行下一次循环。

方法

Java方法是语句的集合，它们在一起执行一个功能。

方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建，在其他地方被引用

设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能，这样利于我们后期的扩展。

方法的定义

方法包括一个方法头和一个方法体。

修饰符返回值类型方法名(参数类型参数名){

方法体

return 返回值;

}

修饰符：可选的，告诉了编译器如何调用该方法。定义了该方法的访问类型
返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType说是关键字void。
方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型，顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
形式参数：在方法被调用时用于接收外界输入数据。
实参：调用方法时实际传给方法的数据。
方法体：包含具体的语句，定义该方法的功能。

方法的调用

对象名.方法名(实参列表)

System.out.print("hello")

方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数。

方法的重载规则：

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

例：

public static void main(String[] args) {
    a();
    a(1);
}
public static void a(){
    System.out.println("无参传递");
}
public static void a(int a){
    System.out.println("int类型传递，传递为="+a);
}

结果：

无参传递
int类型传递，传递为=1

可变参数

JDK1.5开始，java支持传递同类型的可变参数给一个方法。
在方法声明中，指定参数类型后加一个省略号(…)。
一个方法中只能指定一个可变参数，他必须是方法的最后一个参数。任何普通的参数必须在他之前声明。

例：

public static void main(String[] args) {
    a(1,2,3,4,5);
}
public static void a(int... a){
    for (int i : a) {
        System.out.print(i);
    }
}

结果：

12345

递归

递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
递归体：什么时候需要调用自身方法

阶乘例子：

public static void main(String[] args) {
    System.out.println(a(5));
}
public static int a(int a){
    if (a==1){
        return 1;
    }else {
        return a*a(a-1);
    }
}

结果：

120

数组

数组是相同类型数据的有序集合
其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标类访问他们。

数组的声明与创建

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

数据类型[] 数组名字; //定义,首选

数据类型数组名字[]
java语言使用new操作符来创建数组

数据类型[] 数组名字 = new 数据类型[数组大小]
```
int[] a = new int[10];			//定义了一个名为a的数组，大小为10.
```
数组的元素是通过索引访问的，数组索引从0开始。

获取数组的长度：数组名字.lenght

给数组元素赋值：数组名字[元素的下标] = 数值

三种初始化和内存分析

静态初始化：数据类型[] a = {元素1，元素2.......};

int[] a = {1,2,3,4,5}			//数组的大小和内容被确定了

动态初始化(包含了默认初始化)：数据类型[] 数组名字 = new 数据类型[数组大小]
数组默认初始化：数组是引用类型，他的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

在数组被声明时在栈里，直到被new或者说被确定了大小才被储存到堆里。

数组的四个基本特点

数组的长度是确定的，一旦被创建，它的大小就是不可改变的。
其元素必须是相同类型，不允许出现混合类型。
数组的元素可以是任何数据类型，包括基本类型和引用类型。
数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组本身是在堆中的。

数组边界

下标的合法区间：[0,length-1],如果越界就会报错。

ArrayIndexOutOfBoundsException:数组下标越界异常！

数组的使用

public static void main(String[] args) {
    int[] nums = {1,2,3,4,5,6,7,8,9,10};
    //遍历数组元素输出
    for (int i = 0; i < nums.length; i++) {
        System.out.print(nums[i]);
    }
    System.out.println();
    for (int num : nums) {
        System.out.print(num);
    }
    System.out.println();
    //所有元素求和
    int sum = 0;
    for (int i = 0; i < nums.length; i++) {
        sum += nums[i];
    }
    System.out.println("元素的和"+sum);
    //求出元素最大值
    int max = 0;
    for (int i = 0; i < nums.length; i++) {
        if (max<nums[i]){
            max = nums[i];
        }
    }
    System.out.println("元素最大值"+max);
}

运行结果：

12345678910
12345678910
元素的和55
元素最大值10

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

二维数组：数据类型数组名字[][] = new 数据类型[数值][数值];

int a[][] new int[2][3];			//定义了一个int类型名为a的二维数组，一维空间的大小为2，二维空间的大小为3(其实就是两行三列).

Arrays类

public static void main(String[] args) {
    int[] a = {9999999,3,5,6,454,2,54,9,65,89898};
    System.out.println(Arrays.toString(a));        //toString()输出数组元素
    Arrays.sort(a);                                //sort()为数组排序
    System.out.println(Arrays.toString(a));
    Arrays.fill(a,1);                          //fill()填充数组
    System.out.println(Arrays.toString(a));
}

结果：

[9999999, 3, 5, 6, 454, 2, 54, 9, 65, 89898]
[2, 3, 5, 6, 9, 54, 65, 454, 89898, 9999999]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

冒泡排序

//1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
//2.每一次比较，都会产生一个较大或者较小的数字；
//3.下一轮则可以少一次排序！
//4。依次循环，直到结束！
public static int[] sort(int[] array){
    int temp = 0;
    for (int i = 0; i < array.length-1; i++) {
        boolean flag = false;
        for (int j = 0; j < array.length-1-i; j++) {
            if (array[j+1]<array[j]){
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
                flag = true;
            }
        }
        if (flag == false){
            break;
        }
    }
    return array;
}

稀疏数组

当一个数组中大部分元素为0，或者为同一直的数组时，可以使用稀疏数组来保存该数组。
记录数组一共有几行几列，有多少个不同值
把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

public static void main(String[] args) {
    int[][] array = new int[11][11];
    array[1][2] = 1;
    array[2][3] = 2;
    System.out.println("原数组为");
    for (int[] ints : array) {
        for (int anInt : ints) {
            System.out.print(anInt+"\t");
        }
        System.out.println();
    }
    System.out.println("=====================");
    //获取有效值
    int sum = 0;
    for (int i = 0; i < 11; i++) {
        for (int j = 0; j < 11; j++) {
            if (array[i][j]!=0){
                sum++;
            }
        }
    }
    System.out.println("有效值的个数为"+sum);
    //创建一个稀疏数组
    int[][] a = new int[sum+1][3];
    a[0][0] = 11;
    a[0][1] = 11;
    a[0][2] = sum;
    //遍历二维数组，将非零的值，存到稀疏数组中
    int count = 0;
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++) {
            if (array[i][j]!=0){
                count++;
                a[count][0] = i;
                a[count][1] = j;
                a[count][2] = array[i][j];
            }
        }
    }
    //输出稀疏数组
    System.out.println("稀疏数组为");
    for (int i = 0; i < a.length; i++) {
        System.out.println(a[i][0]+"\t"+a[i][1]+"\t"+a[i][2]+"\t");
    }
    System.out.println("=====================");
    System.out.println("还原稀疏数组");
    //读取稀疏数组
    int[][] b = new int[a[0][0]][a[0][1]];
    //给其中元素还原它的值
    for (int i = 1; i < a.length; i++) {
        b[a[i][0]][a[i][1]] = a[i][2];
    }
    System.out.println("还原数组为");
    for (int[] ints : b) {
        for (int anInt : ints) {
            System.out.print(anInt+"\t");
        }
        System.out.println();
    }
}

结果：

原数组为
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0

有效值的个数为2
稀疏数组为
11 11 2

1 2 1

2 3 2

还原稀疏数组
还原数组为
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
for (int[] ints : b) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
}


结果：

原数组为
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	

有效值的个数为2
稀疏数组为
11	11	2	

1	2	1	

2	3	2	

还原稀疏数组
还原数组为
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0