java笔记第一部分

最新推荐文章于 2024-08-12 21:29:36 发布

罗维诺拉

最新推荐文章于 2024-08-12 21:29:36 发布

阅读量123

点赞数

文章标签： java 开发语言 Powered by 金山文档

本文链接：https://blog.csdn.net/qq_42956299/article/details/128664443

版权

本文介绍了Java编程的基础知识，包括编写第一个Java程序，基本数据类型如整数、小数、布尔和字符，以及变量的设置和范围。详细讲解了数组的创建、初始化、访问和异常处理，以及二维数组的操作。还提到了逻辑运算符、流程控制结构如if、switch、循环，并讨论了输入输出，如Scanner类的使用。此外，文章还涵盖了方法的定义与调用，以及字符串的相关操作，如长度、比较和转换。

摘要由CSDN通过智能技术生成

1.第一个java程序

Public class Helloworld{

Public state void main(string[] args){//main主函数

String a = “Helloworld”;//创建字符串变量a,注意大写

System.out.println(a);//打印

}

2.基本数据类型

整数：byte(1字节） short（2字节） int（4字节） long（8字节）

小数：float（4） double（8）

布尔：boolean（ture,false）

字符:char（2字节）

变量设置方法和c语言相同，如：int a = 10;

可以用这种方法找到他们的变量范围：

System.out.println(Byte,MIN_VALUE);

System.out.println(Byte,MAX_VALUE);

输出：

128

127（两个数字中间相隔一行，类比两个数字中间多出一个“\n”）

和c语言一样，int/int=int

一般使用double而不是float

Boolean变量只有两个取值，即ture和false

和c不同，Java的Boolean和int不能转化，不能用1表示ture，0表示false。

自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符：()，但可能造成精度降低或溢出，格外要注意。

通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。

3,赋值运算符(和c一样）

c语言	=	+	-	*	/	%	略，都一样
java	=	+	-	*	/	%	略，都一样

有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大那种数据类型，然后再进行计算。

byte,short,char之间不会相互转换，他们三者在计算时首先转为int类型。

boolean 类型不能与其它数据运算。

当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类型的值将自动转化为字符串(String)类型。

4.比较运算符

和c一样

&&	和	同C语言
\|\|	或	同C语言
！	非	同C语言
^	异或	A^B，即只有当A,B只有一个为ture，才成立

5.逻辑运算符

6.位运算符

7.三元运算符

8,程序流程控制

（8.1）If 同c

（8.2）Switch 同c

表达式的类型必须是：byte,short,int,char,枚举(jdk 5.0),String(jdk 7.0)

（8.3）循环结构

(8.3.1)for循环同c

特别介绍一种循环：foreach循环，可以理解为for循环的简化版，因此在一些复杂的循环里面不适用。

结构

for(元素类型元素名称：循环对象（数组，集合）{

循环语句；

}

特点

在未知循环次数或者计算起来比较复杂的情况下效率比for循环更高。

与for循环区别

foreach循环时循环对象（数组，集合）被锁定，不能对循环对象中的内容进行增删操作，但是可以修改对象内容

例:

String[] str = {“a”,“b”，“c”,“d”};

For(string i;str){

System.out.println(i);

}

（8.3.2）while循环同c

（8.3.3）do-while循环

（8.4）break与cintinue 同c

附加：特殊流程控制语句：return的使用

并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到return语句时，这个方法将被结束。

与break和continue不同的是， return直接结束整个方法，不管这个return 处于多少层循环之内。

9.Java数组

（9.1）数组的初始化

和c语言不同的是，java数组的创建需要一个关键字：new

(9.1.1)动态初始化（指定长度）

例：创建一个长度为3的数组

int[] arr = new int[3];

或者倒过来

int arr[] = new int[3];

也可以分开

int[] arr;

arr = new int[3];

也可以考虑不用new，注意这是不用New的唯一写法

int[] arr = { 1, 2, 3, 4, 5 };

(9.1.2)静态初始化（指定内容）

例：

int[] arr = new int[]{1,2,3,4,5};

//也可以拆分

int []arr;

arr = new[] int{1,2,3,4,5};

//甚至可以更加拆分

Int []arr = new int[3];

arr[0] = 1;

arr[1] = 2;

Arr[2] = 3;

（9.1.3）静态初始化省略格式（不能拆分）

例：

int[] arr = {1,2,3,};

(9.2)数组的访问

Array.fill（A,n）

快速初始化，填充一个数组A,里面所有元素都是数字n

例：

import java.util.Arrays;

Public class fangwen{

Public static void main(String[] args){

int[] arr = new int[5];

Array.fill(arr,1);

System.out.println(Arrays.tostring(arr));

}

数组的访问与c没有什么不同，也是按照arr[i]进行访问

（9.2.1）数组的遍历

其实思路和c语言没有什么不同，就是形式转换一下

for循环遍历

public static void main(String[] args) {

int[] x = { 1, 2, 3 };

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

System.out.println(x[i]);

//System.out.println("x["+y+"]="+x[y]); 打印效果 x[0]=1;

}

foreach遍历方式

public static void mian(String[] args){

int[] arr = {1,2,3,4,5};

For(string i;str){

System.out.println(i);

}

（9.3）二维数组操作

二维数组初始化：

同一维数组一样，有4种不同形式的定义方法

int[][]array1 = new int[10][10];

int array1[][] = new int[10][10];

int array1[][] = {{1,1,1}，{2,2,2}}

int array1[][] = new int[][] {{1,1,1}，{2,2,2}}；

不定长二维数组：

int[][] array = new int[3][];

arrray[0] = new int [1];

arrray[1] = new int [2];

arrray[2] = new int [3];

就以刚刚设立的不定长二维数组为例子，获取它的长度

int len1 = array.length;

int len2 = array[0].length;//获得二维数组的第一维长度，也就是3；

(9.3)数组在内存中的储存

public static void mian(Stru=ing[] args){

int[] arr = new int[3];

System.out.println(arr);

}

这种情况下，没有对arr数组进行赋值，输出的其实是数组在内存中的地址。

new出来的地址，都是在堆内存中储存的，而方法中的变量arr保存的是数组的地址。

堆是什么？凡是new出来的，都在堆里面，且具有默认值，规则：

整数	浮点数	字符	布尔	引用类型
0	0.0	“\u0000”	false	Null

提到堆，就要提到栈。

栈是什么？它存放方法中的局部变量。方法的运行一定要在栈当中运行。

相关定义：作用域，局部变量。同c。

(9.4)数组常见异常

(9.4.1)数组越界异常

例：

public static void main(String[] args){

int[] arr = {1,2,3};

System.out.println(arr[3]);

}

我们只赋值三个元素，却要求输出arr[3]，越界。

（9.4.2）数组空指针异常

例：

public static void main(String[] atgs){

int[] arr = {1,2,3};

arr = null;

System.out.println(arr[0]);

}

arr = null;的操作，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行有NullPointException异常。

（9.5）数组常见操作

(9.5.1)数组反转

反转是什么？就是把1,2,3变成3,2,1。

中心思想：对称元素交换位置。

例：

Publiic static void(String[] args){

int[] arr = {1,2,3,4,5};

for(int max = 4,min = arr.lrngth - 1;min <= max;min++,max- -{

int temp = arr[min];

arr[min] = arr[max];

arr[max] = temp;

}

(9.5.2）数组获取最大元素

同c

（9.5.3）数组排序

public static void main(String[] args){

int[] arr = {112,31,23,3};

array.sort(array);

System.out.println(arr);

}

这一步比c简单捏。

（9.6）数组相关API

输出数组	Arrays.toString() 即：System.out.println(Arrays.toString(array));
数组中是否包含n	String[] array = {“a”,”b”,”c”}; boolean isEle = Arrays.asList(array).contains(“a”); //建立boolean量isEle来判定 System.out.println(isEle);
数组复制	（法1）int array1[] = {1,2,3,4,5}; int array2[] = new int[array1.length]; System.arraycopy(array1,0,array2,0,length); 即：System.arraycopy(原数组，原数组拷贝起始位，新数组，新数组拷贝起始位，要拷贝的数组长度);
数组合并	int[] array1 = {1,2,3,4,5}; int[] array2 = {2,5,6,7,8}; int[]array = org.apache.commons.lang.ArrayUtils.addAll(array1,array2); Syatem.out.println(Array.toString(array)); String数组转字符串（使用指定字符拼接） String[] array = {“a”,“b”,“c”}; 注意这里把上面的AraayUtils变为StringUtils String str = org.apache.commons.lang.StringUtils.addAll(array,“m”); System.out.println(str);
数组逆序	int[] array = {1,2,3,4,5}; org.apache.commons.lang.ArrayUtils.reverse(array); System.out.println(Arrays.toString(array));
数组元素移除	int[] array = {1,2,3,4,5}; int[] removed = org.apache.commons,lang.ArrayUtils.removeElement(array,3); Syatem.out.println(Array.toString(removed));

数组和list,set的转换

数组转List

String[] array = {“a”,“b”,“c”};

System.out.println(array);

List list = new ArrayList(Arrays.asList(array));

System.out.prinln(list);

list.add(“GG”);

System.out.println(list);

数组转set

String[] array = { "a", "b", "c", "d", "e" };

Set set = new HashSet(Arrays.asList(array));

System.out.println(set);

list转数组

List list = new ArrayList();

list.add("a");

list.add("b");

list.add("c");

String[] array = new String[list.size()];

list.toArray(array);

for (String s : array)

System.out.println(s);

java的输入与输出

（10.1）输入（键盘录入）

通过Scanner 类来获取用户的输入，每个next获取输入对应的字符。

由于scannner类是java.until的一个类，我觉得可以理解为c里面的头文件，因此，在使用之前，需要写：

import java.util.Scanner;//导入包（位置放在class定义上面）

当我们通过Scanner 类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext与hasNextLine判断是否还有输入的数据。

举例：

import java.util.Scanner;//步骤1：导包

public class HomeWord1 {

public static void main(String[] args){

//步骤2：创建对象，表示现在准备用scanner这个类

Scanner sc = new Scanner(System.in);

//步骤3：接收变量

//变量data记录了键盘录入的数据

int data = sc.nextInt();//注意这里我们输入的是整数

System.out.println(data);

}

（10.2）输出

System.out.println("Hello Java"); // 输出后换行

System.out.print("Hello Java\n"); // 与println效果相同

System.out.print("Hello Java"); // 输出不换行

System.out.printf("%d",10); // 格式化的输出。

其实可以看出，输出方式与C语言基本相同。

方法（method）

（11.1）什么是方法

方法是程序最小的执行单元。

例：

Public class Helloworld{

Public state void main(string[] args){//main方法，又叫主方法

String a = “Helloworld”;

System.out.println(a);

}

我觉得方法可以类比c里面的函数。因为方法是最小的执行单元，所以，方法里面的语句，必须一同执行。

方法可以把需要重复使用的代码打包，然后进行反复调用，避免代码的冗杂，同时提高代码的可维护性。

（11.2）方法定义和调用

方法就是打包代码以方便调用。

其中，对代码的打包称为方法定义。

（11.2.1）最简单的方法定义与调用

格式：

public static void 方法名(){

方法体；//即，方法中打包起来的代码

}

现实运用：

Package com.itheima.methoddemo;//导包

Public class MethodDemos{

Public static void main(String[]args){

getSum();

}

Public static void getSum(){

int num1 = 10;

int num2 = 20;

int result = num1 + num2;

System.out.println(result);

}

现在只能求一次sum，很麻烦，所以引入：带参数的方法。

（11.2.2）带参数的方法定义与调用

例：

import java.util.Scanner;

Package com.itheima.methoddemo;

Public class MethodDemos{

Public static void main(String[]args){

int num1;

int num2;

Scanner sc = new Scanner(System.in);

int num1 = sc.nextInt();

Int num2 = sc.nextTnt();

getSum(num1,num2);

}

Public static void getSum(int num1,int num2){

//其实和c语言一样，也是把要用的变量写在括号里面

int result = num1 + num2;

System.out.println(result);

}

（11.2.3）带返回值的方法定义与调用

例：求商场季度营业额

import java.util.Scanner;

Package com.itheima.methoddemo;

public class MethodDemos{

public static void main(String[]args){

//除了像刚刚一样直接调用，也可以把结果赋值，这里有返回值，用赋值调用。

Int sum = getSum(10,20,30);

System.out.println(sum);

//或者用输出调用

System.out.println(getSum(10,20,30));

}

//下面对于有返回值的函数，返回的是double ，如果不返回就写void，返回int就int,跟c一个道理

public static_double getSum(int num1,num2,num3){

int result = num1 + num2 + num3;

return result;//也是用return

}

（11.3）return的用法

在没有返回值的函数中

return单独成立一条语句，类似于break或者continue，后面不能跟任何的数值

作用：结束整个方法

在有返回值的函数中

这种情况下函数中必须出现return ，return后面必须跟一个具体的数值，而且数值的类型和返回值类型必须保持一致

作用：结束整个方法，并且将返回值携带给调用者

如果一个自定义的函数有返回值，并且在方法中遇到了分支结构，使用return 在每一个分支后面都需要出现一个return

public class Demo {

public static void main(String[] args) {

show();

}

public static void show() {

System.out.println("Hello World!");

int x = 10;

if (x > 5) {

return;//结束方法 }

}

// 不能执行

System.out.println("Hello World!========");

}

（11.4）参数的重载

同一个类中，方法名字相同，参数列表不同，则是方法重载。

注意：

参数列表的不同包括，参数个数不同，参数数据类型不同，参数顺序不同。

方法的重载与方法的修饰符和返回值没有任何关系。

例：

public class Demo {

public static void main(String[] args) {

show();

show(10);

show("10");

show("10",10);

}

public static void show() {

System.out.println("无参无返回值的show");

}

public static void show(int a) {

System.out.println("int的show");

}

public static void show(String a) {

System.out.println("String的show");

}

public static void show(String a,int b) {

System.out.println("String int的show");

}

（11.5）拓展：实例方法和类方法

例：

public class Demo {

float a;

//实例方法

void sum(float num1,float num2){

a = Max(num1,num2);

}

//类方法

static float Max(float num1,float num2){

//取最大值

return num1 <= num2 ? num2 :num1;

}

public static void main(String[] args) {

Demo demo =new Demo();

demo.sum(22,33); //实例方法必需先初始化类的实例，然后通过类的实例才能调用

Demo.Max(12,9); // 类方法可以直接通过类名调用

}

（标注：感觉还是不太理解）

字符串

（12.1）字符

isLetter()	是否是一个字母
isDigit()	是否是一个空白字符
isWhitespace()	是否是一个空白字符
isUpperCase()	是否是大写字母
isLowerCase()	是否是小写字母
toUpperCase()	指定字母的大写形式
toLowerCase()	指定字母的小写形式
toString()	返回字符的字符串形式，字符串的长度仅为1

转义字符

\t	在文本当前位置插入一个制表位
\b	在文本当前位置插入一个退格
\n	在文本当前位置换行
\r	在文本当前位置插入一个回车
\f	在文本当前位置插入换页符
\'	在文本当前位置插入单引号
\"	在文本当前位置插入双引号
\\	在文本当前位置插入反斜杠

（12.2）string类字符串

字符串分为两类，string类和StringBuffer类。

String类：创建之后不会再做修改和变动的字符串常量。

StringBuffer类：创建之后允许再做更改和变化的字符串变量。

（12.2.1）字符串的创建

对于String类型，初始化的方式有三种，可以参考数组

比如我们创造一个字符串名为username

String username = "";

Username = "Tom"；

或者

String username = "Hello world";

或者

String username = new String("Tom");

（12.2.2）字符串相关API

获取字符串的长度	length（）
字符串连接	string1.concat(string2); 还有一个更直观的方式： String str = str1 + str2;
字符串相似度比较	Str1.equals(str2); //严格比较字符串是否相同 str1.equalsIgnoreCase(str2); //忽略字母大小写来进行比较
比较字符串长度	Str1.compareTo(str2); 若调用方法的字符串比较参数字符串大，返回正整数；若比参数字符串小，则返回负整数；若两字符串相等，则返回0；若两个字符串各个位置的字符都相同，仅长度不同，则返回值为两者长度之差。
字符串的查找	int indexOf(char ch)：搜索字符ch出现的第一个索引号，如果没有找到匹配，则返回-1； int indexOf(char ch,int fromIndex)：从fromIndex位置开始搜索字符ch出现的第一个索引号； int indexOf(String str)：搜索字符串str出现的第一个索引号。
截取字符串	String substring(int index)：提取从位置索引开始的字符串部分； String substring(int beginindex,int endindex)：提取beginindex到endindex-1为止的字符串部分
字符串替换	string1.replace(char oldchar,char newchar) 即：把string1里面的字符串oldchar替换成newchar
字符数组转换为字符串	public class myfirst { public static void main(String[] args) { char []helloArray= {'h','e','l','l','o'}; //声明一个字符数组 String helloString=new String(helloArray); //将字符数组作为构造函数的参数 System.out.println(helloString); } }
字符串替换为字符数组	public class myfirst { public static void main(String[] args) { String helloString ="hello"; //声明一个字符串变量并赋值 char []helloArray=helloString.toCharArray(); //进行字符串和字符数组的转换 for(int i=0;i<helloArray.length;i++) { //for循环输出字符数组 System.out.print(helloArray[i]+" "); } } }