第1章 Java语言基础知识-优快云博客

本文链接：https://blog.youkuaiyun.com/zmmtql/article/details/134168851

√Java面向对象程序设计简介

1.程序设计语言发展历程：

机器语言->汇编语言->高级语言->面向对象语言

2.面向对象思想：

通过抽象找出同一类对象的共同状态和行为，构成类

3.面向对象技术给软件发展带来的益处：

可重用性，可靠性

4.面向对象语言的基本特性：

抽象和封装

继承

多态

√基本数据类型与表达式

1.变量与常量

标识符

1.什么是标识符？

可以由自己命名的地方都称为标识符。

例如，对于常量、变量、函数、语句块、类、项目等都需要一个名字，这些我们都统统称为标识符。

2.命名规范

①三点要求：

标识符有字母、数字、_(下划线)、$所组成，其中不能以数字开头，不能用Java中的保留字（关键字）
标识符采用有意义的简单命名
"$"不要在代码中出现。（是由于在后面内部类中，编译后会出现$符号）

②命名规范（驼峰命名法）

类名和接口名：每个单词的首字母，其余为小写。（大驼峰）

方法名：第二个单词起的首字母为大写，其余全为小写。（小驼峰）

常量名：基本数据类型的常量名使用全部大写字母，字与字之间用下划线分隔。

变量与常量

1.常量：固定不变的量，如 1，2，'A'，null

2.文字量：也称文字常量，如 25，3.1415926

3.变量：程序运行期间，内容可以发生改变的量

一个变量每次只能保存一个数据，必须要明确保存的数据类型

基本数据类型：整数、浮点数、字符、布尔。

引用数据类型：类、数组、接口

2.基本数据类型

数值型

整数类型：

Byte：使用1个字节存储，范围为-128~127；
short：使用两个字节存储，范围为-32768~32767；
int：使用4个字节存储，范围:正负21亿
long：使用8个字节存储

（注意：默认都是int类型，如果需要使用long类型，必须在数字后面加上大写L）

浮点类型：

Float:单精度，使用4字节存储，精确到小数点后7位有效数字
double:双精度，使用8字节存储，精确到小数点后14位有效数字

注意：①默认浮点类型为double；②使用float的时候，数字后面要添加F;

字符型

char：占用2个字节，使用时用''单引号表示；'A';表示一个字符，"A"表示一个字符串，即一个字符序列。

转义字符：

布尔型

boolean：只有true和false两个值，存储时占1位。

用来做逻辑判断，一般用于流程控制
不要写成if（is==true&&done==false），正常应该写if（whether&&！done）

3.运算符与表达式

算数运算符

两个数据做除法，/取结果的商，%取结果的余数

字符的“+”操作

‘a’ – 97 a-z是连续的，所以’b’对应的数值是98，'c’是99，依次递加

‘A’ – 65 A-Z是连续的，所以’B’对应的数值是66，'C’是67，依次递加

‘0’ – 48 0-9是连续的，所以’1’对应的数值是49，'2’是50，依次递加

// 可以通过使用字符与整数做算术运算，得出字符对应的数值是多少
char ch1 = 'a'; System.out.println(ch1 + 1); // 输出98，97 + 1 = 98
char ch2 = 'A'; System.out.println(ch2 + 1); // 输出66，65 + 1 = 66
char ch3 = '0'; System.out.println(ch3 + 1); // 输出49，48 + 1 = 49

字符串的“+”操作

在”+”操作中，如果出现了字符串，字符串前为算术运算，字符串后为连接运算符。

System.out.println(1 + 999 + "年雪碧"); // 输出：1000年雪碧
System.out.println(1 + 2 + "java" + 3 + 4); // 输出：3java34 //可以使用小括号改变运算的优先级
System.out.println(1 + 2 + "java" + (3 + 4)); // 输出：3java7

赋值运算符

基本赋值运算符： =

扩展赋值运算符： +=、-=、*=、/=、%=

关系运算符

大于 >

= 大于等于

< 小于

<= 小于等于

== 等于

!= 不等于

注意： = 是赋值运算符； == 是关系运算符

关系运算符的运算结果一定是布尔类型（true/false）

逻辑运算符

条件运算符

布尔表达式?表达式 1:表达式 2

运行原理：布尔表达式的结果是 true 还是 false，如果是 true，选择表达式 1 的结果;反之则选择表达式 2 的结果

4.类型转换

扩展转换与窄化转换

1.扩展转换:

将小范围数据类型赋值给大范围数据类型,如 int数值赋值给 float变量

2.窄化转换:

将大范围数据赋值给小范围数据,如 float数值赋值给int变量

3.窄化转换的结尾和舍入:

浮点数10.9转为整形后，保存的整形数是截断小数部分的10，还是四舍五入后的11？

截尾: (int)为截尾转换
舍入: Math.round()为舍入转换

隐含转换与显式转换

隐含转换：赋值转换、方法调用转换、字符串转换

使用String的valueOf方法把数值、布尔、字符、字符数组等变量转换为字符串

String change = String.valueOf(111);

显式转换（强制转换）

√数组

1.初始化

数组默认值：

静态初始化（指定长度）

int[] arr = new int[3];  
int   arr[] = new int[3];
// 可以拆分 
int[] arr;
arr = new int[3];

动态初始化（指定内容）

int[] arr = new int[]{1,2,3,4,5}; 
// 可以拆分 
int[] arr;
arr = new int[]{1,2,3,4,5};

扩展方法： `Arrays.fill`快速初始化，填充一个数组

Java中的数组初始值都为零，若快速填充一个其他值的数组，即将数组批量填充相同的值，可以用 Arrays.fill 方法，但只能填充一个一维数组，多维数组还得用循环。

import java.util.Arrays;

public class HelloWorld {
    public static void main(String[] args) {
        int[] arr = new int[5];
        Arrays.fill(arr, 1);
        System.out.println(Arrays.toString(arr));  // [1, 1, 1, 1, 1]
    }
}

虽然Arrays.fill方法不能填充二维数组，不过在下面这种情况下，还是可以用一下的：

当row中的数值不固定，也不一定有规律时，可以用Arrays.fill()来填充二维数组，使其每一行都是｛1，2，6，3，6，1，7｝

  int[][] map=new int[4][5];
   int[] row={1,2,6,3,6,1,7};
   Arrays.fill(map,row);  
   //每一行都是｛1，2，6，3，6，1，7｝

2.修改数组：

数组的长度属性：数组名.length-1

下标从0开始，最大到length-1

Arrays.aslist()方法：

将数组转化为List集合

  int[][] map=new int[4][5];
   int[] row={1,2,6,3,6,1,7};
   Arrays.fill(map,row);  
   //每一行都是｛1，2，6，3，6，1，7｝

Arrays.aslist()返回的集合是一个视图，该集合和原数组共享一份数据，所以修改集合中的元素会改变原数组中的元素

public class experiment {
    public static void main(String[] args) {
        Integer[] arr = {1, 2, 3, 4, 5};
        List<Integer> list = Arrays.asList(arr);
        list.set(0,2);
        System.out.println(list);
    }
}
//运行结果：[2,2,3,4,5]

3.遍历数组：

(1)for循环打印数组

public class Test {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
    }
}

(2)foreach打印数组

public class Test {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        for (int x:array) {
            System.out.print(x+" ");
        }
    }
}
//foreach只能访问，不能修改

(3)toString打印数组

将数组的数据变成字符串类型数据

import java.util.Arrays;
 
public class Test {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        System.out.println(Arrays.toString(array));//使用toString方法需要导包，类似C语言中的头文件
    }
}
//运行结果：[1,2,3,4,5]

4.复制数组

Arrays.copyOf 方法复制指定数组

copyOf(int[] original,,int[] newLength)

第一个参数original - 要复制的数组

第二个参数newLength - 要返回的副本的长度

import java.util.Arrays;
 
public class Test {
 
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] newArray = new int[array.length];//新数组
        newArray = Arrays.copyOf(array,array.length);
        System.out.println(Arrays.toString(newArray));
    }
}
//运行结果：[1,2,3,4,5]

Arrays.copyOfRange()方法指定起止位置

int[] arr1 = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int[] arr2 = new int[5];
arr2 = Arrays.copyOfRange(arr1,3,5);
System.out.println("Arr2的内容是："+Arrays.toString(arr2));
//运行结果：Arr2的内容是:[4，5]

5.查找数组中元素

顺序查找

public class Test {
    public static int find(int[] array,int k){
        for (int i = 0; i < array.length; i++) {
            if(k == array[i]){
                return i;//找到了就返回下标
            }
        }
        return -1;//找不到返回-1
    }
 
    public static void main(String[] args) {
        int[] array = {1,2,3,0,7,8,9,4,5,6};
        int ret = find(array,4);
        System.out.println(ret);
    }
}
//运行结果：7

二分查找binarySearch（必须为有序数组）

import java.util.Arrays;
 
public class Test {
 
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7,8,9,10};
        int ret = Arrays.binarySearch(array,4);
        System.out.println(ret);
    }
}
//运行结果：3

6.数组排序sort

(1)Arrays.sort(数组名)

sort只能顺序排序，想要逆序排序可以逆序输出

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        int[] array = {1,2,3,6,5,0,4,8,7,9};
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }
}
//运行结果：[0,1,2,3,4,5,6,7,8,9]

(2)Arrays.sort(数组名，起始下标，排序个数)

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] arr = {5, 2, 3, 1, 0, 1};
        Arrays.sort(arr,1,4);
        System.out.println(Arrays.toString(arr));
    }
}
//运行结果：[5, 1, 2, 3, 0, 1]

注：对字符串进行排序是对每一个字符比较，而不是简单的比较长度。像：

 str1 = abcdf
 str2 = abcdef

因为f大于e所以str1>str2

7.比较数组

比较数组内容：

如果相等返回true，否则返回false

int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
boolean isEqual = Arrays.equals(arr1, arr2);
System.out.println(isEqual);
//运行结果：true

比较数组地址：

String str1 = "hello";
String str2 = "hello";
String str3 = new String("hello");
System.out.println(str1.equals(str2));
System.out.println(str1.equals(str3)); 
//运行结果：true

8.二维数组

二维数组定义：

三种定义方式

public class Test {
 
    public static void main(String[] args) {
        int[][] array1 = {{1,2,3},{4,5,6}};
        int[][] array2 = new int[2][3];
        int[][] array3 = new int[][]{{1,2,3},{4,5,6}};
    }

二维数组打印：deepToString

import java.util.Arrays;
 
public class Test {
 
    public static void main(String[] args) {
        int[][] array = {{1,2,3},{4,5,6}};
        System.out.println(Arrays.deepToString(array));
    }
    //运行结果：[[1,2,3],[4,5,6]]

*算法的流程控制

//if语句
if(boolean_expression)

{

    statement;

}


//if else语句
if(bo0lean_expression)
{
	 statement;
}
else
{
	 statement;
}


//if else语句特殊形式
if(bo0lean_expression)
{
	 statement;
}
else if(bo0lean_expression)
{
	 statement;
}
else if(bo0lean_expression)
{
	 statement;
}

switch语句

switch(switch_expression)
{
case value1:statements for case1;break;
case value2:statements for case2;break;
...
case valuen:statements for casen;break;
default:statements for default case;break;
}

1.default可有可无

2.switch_expression,value1...valuen必须为int或char型

for语句

for(i=0;i<n;i++)
{

}

增强for循环

int nums[]=new int[]{1,2,3,4,5};
for(int num:nums)
{

}

while语句

while(expression)
{

}

do while语句

至少执行一次

do {

}while(expression);

break语句

终止break语句所在最内层循环

continue语句

终止当前这轮循环，跳出本轮循环剩余语句，直接进入下一轮循环