java基础知识回顾

最新推荐文章于 2024-08-29 18:44:48 发布

Adopat

最新推荐文章于 2024-08-29 18:44:48 发布

阅读量145

点赞数

分类专栏： java 基础复习文章标签： java 编程语言

本文链接：https://blog.csdn.net/weixin_44446122/article/details/104805917

版权

java 基础复习专栏收录该内容

5 篇文章 0 订阅

订阅专栏

java开发环境的搭建

JRE

JAVA运行环境，包含JVM和运行时所需要的核心类库

JDK

java程序开发工具包，包含JRE和开发人员所需要使用的工具

JVM

JAVA虚拟机，关于java虚拟机后续会通过一个详细笔记介绍

java第一个程序Hell world

java开发程序开发的三个步骤

编写
编译 javac.exe编译器
运行 java.exe解释器

--创建HelloWorld.java源文件
public class HelloWorld{
	public static void main(String[] args){
		System.out.println("Hello World!!");
	}
}

java中的注释

单行注释：//
多行注释：/*/

关键字

被保留的，不能随意被使用的字符，有特殊含义
关键字的特点：完全小写的字母，增强型记事本中有特殊的颜色标识

标识符

标识符
- 是指在程序中，用户自己定义的内容，比如类的名字，函数的名字，方法的名字
命名规则：硬性要求
- 只能时英文字母，数字，美元符号和下划线组成
- 标识符不能以数字开头
- 标识符不能时关键字
命名规则：软性要求
- 类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）
- 变量名规范：首字母小写，后面每个单词首字母大写（小驼峰式）
- 方法名规范：同变量名

常量

在程序运行过程中固定不变的量
常量的分类
- 字符串常量
- 整数常量
- 浮点数常量
- 字符常量
- 布尔常量：true,false
- 空常量:null（注意null值在数据库中可以代表任何类型）
```
--DemoConst
public class DemoConst{
	public static void main(String[] args){
		System.out.println('a');
		System.out.println("abc");
	}
}
```

数据类型

基本数据类型
- 整数型 byte short int long
  - byte 占用1个字节取值范围 -128-127
  - short 占用2个字节
  - int(默认) 占用4个字节
  - long 占用8个字节
- 浮点型 float double
  - float 占用4个字节
  - double(默认) 占用8个字节
- 字符型 char
  - char 占用2个字节取值范围 0-65535
- 布尔型 boolean
  - boolean 占用一个字节取值范围 true,false
引用数据类型
- 字符串
- 数组
- 类
- 接口
- Lambda
基本数据类型中要注意的事项
- 字符串不是基本数据类型，它是引用类型
- 浮点型可能只是一个近似值，并非精确的值
- 数据范围与字节数不一定相关，例如floa数据范围比long更加广泛，但是float是4字节,long是8字节
- 浮点数中么人数据类型是double ,如果要更改float类型,要加上一个后缀F
- 如果是整数的默认范围是int 如果要使用Long类型，要添加后缀L，后缀都建议使用大写的字母

变量

程序运行期间，内容可以发生改变的量
创建一个变量并且使用的格式
- 数据类型变量名称;//创建了一个变量
- 变量名称=数据值

--创建java文件DemoVariable.java
public class DemoVariable{
	public static void main(String[] args){
        int num;
        num=10;
        System.out.println(num);
        int num1=20;
		System.out.println(num1);
		long num2=3000000000L;
		System.out.println(num2);
    }
}

使用变量的时注意事项

变量名不能相同
对于long,float类型，字母后缀F和L不能丢
变量一定要先赋值才可以使用
如果使用byte 和short 右侧的赋值一定不能超过左侧数据类型的范围
变量的使用不能超过作用域的范围，作用域：从定义变量的第一行开始，一直到所属的大括号结束为止。所属的大括号是离定义变量最近的大括开是到结束
可以同时定义多个变量

--创建DemoVariableNotice.java
public class DemoVariableNotice{
	pubic static void main(String[] args){
		int num;
		System.out.println(num);//报错变量没有进行赋值
		System.out.println(num1);//超出变量的作用域，程序执行的顺序是从上到下一次执行的
		int num1=10;
		{
		int num2=60;
		System.out.println(num2);//可以正常输出
		}
		System.out.println(num2);//输出报错,超出了变量的定义作用域
		int x=100,y=200,z=300,
		System.out.println(x);
		System.out.println(y);
		System.out.println(z);
	}
}

数据类型转换

自动类型转换,用大的数据范围装小的数据范围，会自动发生数据类型隐式转换，注意float是4个字节，但是long是8个字节，但是float的数据范围是大于long 类型的，所以一个long类型的数据可以赋值给float类型的数据，这其中会发生自动数据类型转换

--Demo01DataType.java
public class Demo01DataType{
	public static void main(String[] args){
		long num1=100;
		System.out.println(num1);
		//左边是float类型，右边是long类型，左右不一样，但是float的数据范围是大于long 类型，会自动发生数据类型转换
		float num2=100L;
		System.out.println(num2);
	}
}

强制转换，用数据范围小的装数据范围大的，代码需要进行的特殊的处理，不能自动完成

特点：代码需要进行特殊的格式化处理，不能自动完成
格式：范围小的数据想要装范围大的数据
注意事项：强制类型转换一般不推荐使用，因为有可能发生精度的缺失，和数据溢出
- 数据溢出：一般来说如果我们要使用一个数据范围小的类型来装一个数据范围大的数据，在没有超过其数据范围的情况下，我们需要进行强制的类型转换，如果超过了其左边的数据范围，则我们在进行强制类型转换的是后会发生数据溢出，根本装不下的数据
- 精度的缺失：发生在浮点数进行强制类型转换的情况，注意不是取整，所有的小数都会被丢弃
byte/short/long /int /char这几种数据类型都可以进行数学运算，例如‘+’
byte/short/char 在进行计算的时候首先会被提升为int类型，然后进行计算
boolean类型不能进行数据类型转换

--Demo02DataType.java
public class Demo02DataType{
	public static void main(String[] args){
		//想用int类型的数据装long 类型的数据，会发生数据类型的强制转换，，程序会发生报错
		int num1=(int)100L;
		System.out.println(num1);
	}
}

--DemoDemo02DataType
public class Demo02DataType{
	public static void main(String[] args){
		//byte数据范围-127-128，数据范围装不下到值数据溢出
		byte num11=(byte)129;
		System.out.println(num11);
		int num22=6000000000;
		System.out.println(num22);//导致数据溢出，数据范围超出int范围
		int num3=(int)3.99;
		System.out.println(num33);//发生精度的缺失，注意四所有小数位都被舍弃掉，并不是四舍五入
		char zifu1='A';
		System.out.println(zifu1+1);//输出结果66，因为char类型在进行计算的时候首先会被提升为int类型然后在进行计算
		byte num44=40;
		byte num55=50;
		byte result=num44+num55;//结果报错，在byte类型进行相加的时候，会优先将byte提升为int类型，这里要进行强制类型转换，修改为byte result=(byte)(num44+num55)或者int result=num44+num55;
		int result=num44+num55;
		System.out.println(result);
		
	}
}

ASCII编码表

ASCII:美国信息交换标准代码
Unicode码表:万国码，0-127部分和ASCII码完全一样，但从128开始包含更多字符，包括Emoj

记住三个ASCII值；48–'0 '65–‘A’ 97–‘a’

--Demo03DataTypeChar
public class Demo03DataTypeChar{
	public static void main(String[] args){
		char zifu3='a';
		//int 取值范围大于char取值范围，发生了自动类型转换
		int num=zifu3;
		System.out.println(num);
		char zifu4='中'
		System.out.println(zifu4);
	}
}

运算符

算数运算符
- - 加法有以下三种常见的用法
    - 对于数值类型来说就是加法
    - 对于字符char来说，在计算时，char会被提升为int,然后在计算，char和int类型的对应关系表ASCII和unicode
    - 对于字符串来说String,加号代表字符串的连接操作，注意任何数据类型和字符串进行连接操作时，都会变成字符串
```
--Demo05Plus.java
public class Demo05Plus{
	public static void main(String[] args){
		String str1="Hello";
		System.out.println(Str1+" Java");//Hello Java
		System.out.prinln(Str1+20);//Hello20
	}
}
```
- /
- %取模运算
- ++ --自增自减运算
  - 只有变量能够使用自增自减运算，常量不可发生改变，所以不能使用
  - 使用格式，写在变量前和变量后 num++,++num
  - 使用方式
    - 单独使用：num++,++num效果完全一样
  - 混合使用：和赋值运算一起使用，或者打印操作混合
    - 如果时前++,呢么变量马上+1，然后拿着结果进行使用【前加后用】变量该加还是得加
    - 如果时后++，那么变量先使用，然后再让变量+1【先用后加】变量该加还是得加
  –Demo06Plus.java
  public class Demo06Plus{
  public static void main(String[] args){
  int num=20;
  System.out.println(num);//20
  num++;
  System.out.println(num);//21
  ++num;
  System.out.println(num);//22
  System.out.println("=");
  int num1=20;
  System.out.println(num1++);//20
  System.out.println(num1);//21
  System.out.println("");
  int num2=20;
  System.out.println(++num2);//21
  System.out.println(num2);//21
  //和赋值进行运算
  System.out.println("=");
  int num3=20;
  int result=–num3;//19
  System.out.println(num3);//19
  System.out.println(result);//19
  System.out.println("=");
  int num4=20;
  int result1=num4–;
  System.out.println(result1);//20
  System.out.println(num4);//19
  System.out.println("========");
  int num5=20;
  int num6=30;
  int result2=++num5+num6–;
  System.out.println(result2);
  System.out.println(num5);
  System.out.println(num6);
  }
  }
- 注意事项：一旦运算当中有不同类型的数据，那么结果将会是数据范围大的那种
- byte/short/char在运算中会优先被提升到int然后进行运算
–Demo03Operator.java
public class Demo03Operator{
public static void main(String[] args){
int num=10;
double num1=num+2.5;
System.out.println(num1);//12.5
}
}

赋值运算符

=
+=:a+=1 等价于 a=a+1
-=:b-=4 等价于 b=b-4
*=
/=
%=:e%=7 等价于 e=e%7
注意常量不能进行复合赋值运算，复合赋值运算隐含了一个强制类型的转换

public class Demo07Operator{
	public static void main(String[] args){
		int a=10;
		a +=10;
		System.out.println(a);
		int b=10;
		b -=2;
		System.out.prinyln(b);
		int x=10;
		x %=3;
		System.out.println(x);
		System.out.println("========");
		byte z=10;
		//z=z+10;
		//byte=byte+int;
		//byte=int+int;
		//byte=(byte)int+int
		z +=10;
		System.out.println(z);
	}
}

比较运算符
- ==，>,<,>=,<=,!=
- 注意事项：比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false,进行多次比较不能连着写
逻辑运算符
- 与：&&,全部是true才是true,否则是false
- 或：||,至少一个是true就是true,全都是false才是false
- 非：！,取反
- 注意&&(与)和||（或）具有短路效果，如果根据前面的条件，已经可以判断结果，则后面的条件将不再执行，这样做可以节约一定的性能,f发生短路的情况：&&有false绝对是false,||有true绝对是true
- 逻辑运算符只能用于boolean值
```
--Demo09Logic.java
public class Demo09Logic{
	public static void main(String[] args){
		int a=10;
		System.out.println(3>4 && ++a<100);
		System.out.println(a);//a的值没有发生变化，还是10
		System.out.println("=========");
		int b=20;
		System.out.println(3<4 || ++b<100);
		System.out.println(b);
	}
}
```
三元运算符（三目运算符）
- 一元运算符：只需要一个数据就可以进行操作的运算符，例如取反！自增++，自减–
- 二元运算符：需要两个数据才可以进行的操作符，例如加法+，赋值=
- 三元运算符：需要三个数据才可以进行的操作的运算符
  - 格式：数据类型变量名称 =条件判断？表达式A：表达市B:(注意;不能少)
    - 首先判断条件是否成立，如果为true,将表达式A的值赋值给变量，如果为false将表达式B的值赋值给变量
    - 注意必须同时保证表达式A和表达式B都符合左侧的数据类型的要求
    - 三元运算符的结果必须被使用，要么赋值给变量，要么直接打印输出
```
--Demo10Operator.java
public class Demo10Operator{
	public static void main(String[] args){
	int a=10;
	int b=20;
	int max =10>20?10:20;
	System.out.println(max);
	System.out.println("=======");
	//比较两个数中的最大值并且打印输出
	System.out.println(10>20?10,20);
	}
}
```

方法与循环

方法

方法定义:将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能，当我们需要使用这个功能的时候就可以去调用，这实现了代码的复用性，也解决了代码的冗余

定义格式：

修饰符 返回值类型 方法名（参数列表）{
	代码块;
	return;
}
修饰符：目前固定写法 public static
返回值类型:目前固定写法void
方法名:调用时使用

注意：方法的定义的先后顺序无所谓，方法的定义不能产生嵌套，就是不能在方法的代码块中在定义其他方法，方法定义后不会执行，要在调用后才执行,但是在方法体中可以调用其他方法
方法的调用:
```
方法的调用格式:
方法名称();
```

JShell脚本工具

JShell脚本工具时JDK9的新特性，当我们编写的代码非常少的时候，而不愿意编写类，main方法，也不愿意去编译运行，这时候就可以使用JShell工具
JShell的启动:DOS下输入JShell
JShell的退出:DOS下输入/exit

编译器的两点优化

对于byte/short/char来说，如果右侧的赋值没有超过其范围，呢么javac编译器会自动隐含的为我们补上一个强制类型转换，如果右侧的赋值超过了其范围，会直接编译其报错

对于常量，还有一个常量优化，在给变量进行赋值的时候，如果右侧的表达式都是常量，没有任何变量，那么编译器javac将会直接将若干个常量的表达式计算的结果直接赋值给变量，注意不能包含变量，也不能超范围

--Demo12Notice.java
public class Demo12Notice{
	public static void main(String[] args){
		byte num1=30;//等等30不是默认int，类型吗？？用一个byte类型去装int类型，不是会发生强制类型转换，正确写法不应该是:byte num1=(byte)30;javac编译器会自动加上，这是一个优化
		System.out.println(num1);
		byte num2=128;
		System.out.println(num2);//编译器直接报错，超出数据范围，这种超出数据范围并不是溢出，而发生的截断
	}
}

流程控制

流程控制:我们可以控制程序的执行顺序来实现我们要完成的功能。
流程控制有四种:顺序结构，判断语句，选择语句，循环语句

顺序结构

判断语句

单if语句

单if语句的格式
if(关系表达式){
	语句体;
}
--Demo02If.java
public class Demo02If{
	int age=16;
	if(age>16){
	++age;
	}
	System.out.println(age);//age 16
}

标准if语句

标准if语句的格式
if(关系表达式){
	语句体;
}else{
	语句体2;
}
//用if else语句来判断一个数是不是偶数
--Demo03If.java
public class Demo03If{
	public static void main(String[] args){
		int num1=13;
		if(num1%2==0){
			System.out.println(num1+"是偶数");
		}else{
			System.out.println(num1+"是奇数");
		}
	}
}

扩展if语句

扩展IF语句的格式
if(判断条件){
	执行语句;
}else if(判断条件){
	执行语句;
}else if(判断条件){
	执行语句;
}else if(判断条件){
	执行语句;
}else{
	执行语句;
}
--Demo04If.java

//根据成绩，判断成绩的等级
public class Demo04If{
public static void main(Strng[] args){
int score=100;
if(score<0||score>100){
System.out.println(“你的成绩是错误的”);
}else if(score>=90&&score<100){
System.out.println(“你的成绩十分优秀”);
}else if(score>=80&&score<89){
System.out.println(“你的成绩好”);
}else if(score>=70&&score<79){
System.out.println(“你的成绩良好”);
}else if(score>=60&&score<69){
System.out.println(“你的成绩刚好及格”);
}else{
System.out.println(“你的成绩不及格”);
}
}
}
//使用三元运算符和标准if else运算来求两个值的最大值
–Demo05If.java
public class Demo05If{
public static void main(String[] args){
int a=10,b=20;
System.out.println(a>b?a:b);
int max=a>b?a:b;
System.out.println(“最大值是:”+max);
if(a>b){
System.out.println(“最大值是:”+a);
}else{
System.out.println(“最大值是:”+b);
}
}
}



##### 选择语句

- 选择语句--switch

```java
--switch语句的格式
switch(表达式){
	case 常量1：
	语句体1;
	break;
	case 常量2:
	语句体2;
	break;
	...
	default:
	语句体n;
	break;
}
//执行流程
首先计算出表达式的值
其次hecase中的常量依次比较，一旦有相应的值，就会执行相应的语句，在执行过程中，遇到break就会执行结束
最后匹配不上就执行default块的语句体,然后程序结束掉，注意default中的break可以省略不写，但是建议写上，养成良好的代码编写规范
//使用switch判断星期
--Demo06Switch.java
public class Demo06Switch{
	public static void main(String[] args){
		int num=1;
		switch(num){
			case 1:
				System.out.println("Monday");
				break;
			case 2:
				System.out.println("Tuesday");
				break;
			default:
				System.out.println("Sunday");
				break;
		}
	}
}
//注意switch小写，break和语句块对齐

switch语句的穿透
- 多个case 的常量值不允许重复
- switch后面小括号只能是以下数据类型，基本数据类型byte/short/char/int,引用数据类型:String类型,enum枚举
- switch语句格式可以很灵活,case 的顺序可以颠倒，break还可以省略，但注意的是如果省略break，将会发生switch穿透，如果default 语句写在最前面，将会导致非常严重的错误，再次说明编码的习惯一定要好，deault写在最后，并且每一个case 中的break都不建议省略包括default中的break
```
//switch穿透案例
--Demo06Switch01.java
public class Demo06Switch01{
	public static void main(String[] args){
		int num=1;
		switch(num){
			case 1:
				System.out.println("Monday");
			case 2:
				System.out.println("Tuesday");
			default:
				System.out.println("Sunday");
				break;
		}
	}
}
//输出结果Monday Tuesday Sunday
```

循环语句

循环结构的组成部分，一般分为四大部分
1. 初始化语句,在循环开始最初执行，而且只做唯一一次
2. 条件判断，条件成立则执行循环语句，条件不成立则跳出循环
3. 循环体，多次执行，若干语句
4. 步进语句，每次循环都要执行

for循环

for循环语句格式:
for(初始化表达式;布尔表达式;步进表达式){
	循环语句;
}
//使用for循环输出1-100的值
--Deno09For.java
public class Demo09For{
	public static void main(String[] args){
			int result=0;
		for(int i=1;i<=100;i++){
			result=result+i;
		}
		System.out.println(result);
	}
}

while循环

--while语句的格式
初始化表达式
	while(布尔表达式){
		循环体;
		步进表达式;
	}
--while循环的标准格式
while(布尔表达式){
	循环体;
}
--while循环的扩展格式
初始化表达式
	while(布尔表达式){
		循环体;
		步进表达式;
	}
--Demo10While
public class Demo10While{
	public static void main(String[] args){
		for(int i=1;i<=10;i++){
			System.out.println("I am a shuaige"+i);
		}
		System.out.println("===============");
		int i=1;
		while(i<=10){
			System.out.println("I am a da shuaige"+i);
			i++;
		}
	}
}

do while循环

--标准Do While格式
do{
	循环体;
}while(布尔表达式);(注意分号一定要有,do-while循环至少执行一次)
--扩展Do-While格式
初始化语句
do{
	循环体;
	步进语句;
}while(布尔表达式);
--Demo10DoWhile.java
public class Demo10DoWhile{
	public static void main(String[] args){
		int i=1;
		do{
			System.out.println("I am a shuaige");
			i++;
		}while(i<=10);
	}
}
//用循环输出1-100的偶数和，总和练习

–Demo12HundredSum.java
public class Demo12HundredSum{
public static void main(String[] args){
int sum=0;
for(int i=0;i<=100;i=i+2){
sum=sum+i;
}
System.out.println(sum);
//for 循环和if 判断语句一起结合使用
int sum1=0;
for(int i=1;i<=100;i++){
if(i%2==0){
sum1+=i;
}
}
System.out.println(sum1);
}
}


- 三种循环的区别

- 如果条件判断从来没有满足过，那么for循环和while循环将会执行0此，do-while循环至少会执行一次

- for循环初始化语句定义在小括号中，只有循环体内部才可以使用，while循环和do-while循环的初始化语句定义在外面，所以出了循环照样可以使用，注意变量的使用范围，

  ```
  --Demo13LoopDiff.java
  public class Demo13LoopDiff{
  	public static void main(String[] args){
  		for(int i=1;i<1;i++){
  		System.out.println("hello")
  		}
  		System.out.println(i);//输出报错
  		System.out.println("==============");
  		int i=1;
  		do{
  			System.out.println("world");
  			i++;
  		}while(i<1);
  		System.out.println(i);//2
  	}
  }
  ```

- 循环控制中的break关键字

- break关键字用法有两种结构

  - 可以用在switch语句中，一旦执行，整个switch语句立刻结束
  - 还可以用在循环语句中，一旦执行，整个循环立刻结束，打断循环
  - 关于循环来说，如果次数确定的循环，我们一般使用for循环，如果次数不确定一般使用while循环

  ```java
  --Demo14Break.java
  public class Demo14Break{
  	public static void main(String[] args){
  		for(int i=1;i<10;i++){
  			if(i>=4){
  				break;
  			}
  			System.out.println("Hello World");
  		}
  	}
  }
  
  ```

- 循环控制中的continue语句

- continue语句的使用，一旦执行，立刻跳出当前此循环，马上开始下一次循环,(注意是当前此的循环)

  ```java
  --Demo15Continue.java
  public class Demo15Continue{
  	public static void main(String[] args){
  		for(int i=1;i<10;i++){
  			if(i==4){
  			continue;
  			}
  			System.out.println(i);
  		}
  	}
  }
  //总结循环中的break和continue的区别
  break中断当前的整个循环，如果满足条件的话
  continue中断当前此的循环，然后接着整个循环的条件接着循环下去
  ```

- 循环中的死循环问题

- 出现死循环的原因，漏写步进表达式，还有一种是人为的死循环,注意如果在死循环后面还有执行语句，语句将不会执行，程序发生编译错误

  ```java
  --Demo16DeadLoop.java
  public class Demo16DeadLoop{
  	public static void main(String[] args){
  		for(int i=1;i<10;){//注意缺少步进表达式for循环也是可以执行的，只是发生了死循环
  			System.out.println(i);
  		}
  		//第二种情况,人为书写死循环，对于不确定次数的循环我们使用while 循环
  		while(true){
  			System.out.println(1);
  		}
  			System.out.println("hello world");//此条语句不在执行，程序发生错误
  	}
  }
  
  ```

- 循环中的嵌套问题

```java
--Demo17LoopHourAndMinutes.java
//利用循环嵌套输出每小时每分每秒
public class Demo17LoopHourAndMinutes{
	public static void main(String[] args){
		for(int hour=0;hour<24;hour++){
			for(int minute=0;minute<60;minute++){
				for(int second=0;second<60;second++){
					System.out.println(hour+":"+minute+":"+second);
				}
			}
		}
	}
}

IDEA的安装使用

IDEA的安装

IDEA的项目结构

项目(project)–>模块(module)–>package

IDEA的快捷键：

alt+4查看上次运行的结果
alt+shift+10运行程序
alt+enter 导入包，自动修正代码
ctr+Y删除光标所在的行
ctr+D赋值光标所在的行的内容，插入到光标位置下面
ctrl+alt+L格式化代码
ctr+/单行注释
ctr+shift+/选中代码注释，多行注释，再按取消注释
alt+ins自动生成代码，toString,get,set等方法
alt+shift+上下箭头移动当前代码行

方法

方法的定义和调用

--Demo01Method.java
//使用传统的方式打印一个矩形
public class Demo01Method{
	public static void main(String[] args){
		for(int j=1;j<=5;j++){
			for(int i=1;i<=20;i++){
				System.out.print("*");
			}
			System.out.println();
		}
	}
}
//通过定义一个方法来执行打印输出矩形星号
--Demo02Method.java
public class Demo02Method{
	public static void main(String[] args){
		printStar();
	}
	public static void printStar(){
		for(int j=1;j<=5;j++){
			for(int i=1;i<=20;i++){
				System.out.print("*");
			}
			System.out.println();
		}
	}
}

方法定义的注意事项：
- 方法定义的顺序先后无所谓
- 方法定义必须是紧挨者的，不要在一个方法的内部定义一个其他方法，
- 方法定义之后不会执行，如果需要执行，则将方法进行调用
- 只要方法进行了定义，则方法的调用可以在方法定义之前
方法定义的格式
- 方法其实就是若干语句块的集合，方法好比一个工厂，入参好比工厂的原料，出参好比工厂的产出物，方法体好比工厂的加工过程；
- 方法定义中要注意的事项，方法名的定义规则要遵循小驼峰命名法(首字母小写从第二个单词开始每个单词的首字母要大写，这种命名的方法和变量是保持一致的)；return 的作用：停止当前的方法；将返回值返回给调用处，注意return 返回值的类型，必须和定义的时候的数据返回类型保持一致，否则方法定义失败
```
--定义方法的格式
修饰符 返回值类型 方法名(参数类型 参数名称...){
	方法体;
	return; 返回值//返回值
}
//定义两个byte类型的数据相加
--Demo02MethodDefine.java
public class Demo02MethodDefine{
	public static void main(String[] args){
		addByte((byte)1,(byte)2);//单独调用
	}
	public static int addByte(byte a,byte b){
		int sum=a+b;
		return sum;
	}
}
```

方法调用的三种格式

单独调用，如上代码就是属于单独调用，如果返回值类型是void只能进行单独调用，不能进行打印调用和赋值调用
打印调用：System.out.println(addByte((byte)1,(byte)2));

赋值调用:将方法的返回值赋值给一个变量，然后将变量值进行赋值打印输出

public class Demo02MethodDefine {
    public static void main(String[] args) {
        sum(5,5);//单独调用，如果返回值是void 只能进行单独调用
        System.out.println(sum(20,20));//打印调用
        int result=sum(10,10);
        System.out.println(result);//赋值调用
    }
    public static int sum(int a,int b){
        int sum=a+b;
        return sum;
    }
}

方法调用的四个流程：
1. 找到方法名，寻找方法定义
2. 传递方法的参数
3. 执行方法体
4. 将执行的结果return 回方法调用处

方法中的参数

有参数：当一个方法需要一些数据条件，才能完成任务的时候，就需要带有参数，例如之前的求两个数的和

无参数：不需要带参数也能完成任务的情况

--Demo03MethodParam.java
public class Demo03MethodParam{
	public static void main(String[] args){
		printStar();
		System.out.println("============");
		System.out.println(sum(10,20));
	}
	//定义一个无参函数
	public static void printStar(){
		for int(j=1;j<=5;j++){
			for(int i=1;i<=20;i++){
				System.out.print("*");
			}
				System.out.println();
		}
	}
	//定义一个带参的函数，求两个数的和
	public static int sum(int a,int b){
		int sum=a+b;
		return sum;
	}
}

方法中的返回值

带有返回值:返回值类型要和方法中定义的返回值类型相同
无返回值（void）

注意：对于有返回值的方法，可以使用单独调用，也可以打印调用或者赋值调用，对于没有返回值的方法，只能使用单独调用，不能使用打印调用和赋值调用

--Demo04MethodReturn.java
public class Demo04MethodReturn {
    public static void main(String[] args) {
        int result=sum(10,20);
        System.out.println(result);
        System.out.println("=============");
        sumPrint(20,50);
        System.out.println("================");
        //没有返回值的类型不能使用打印调用和赋值调用
       // System.out.println(sumPrint(10,20));
    }
    //定义一个函数求出两个数的和有返回值
    public static int sum(int a,int b){
        int sum=a+b;
        return sum;
    }
    //定义一个函数求出两个数的和并打印出来
    public static void sumPrint(int a,int b){
        int sum=a+b;
        System.out.println(sum);
    }
}

方法的小练习

--比较两个数字是否相同Demo01MethodSame.java
public class Demo01MethodSame {
    public static void main(String[] args) {
        System.out.println(isSame(10,20));
        System.out.println("============");
        System.out.println(isSame1(10,10));
        System.out.println("===================");
        System.out.println(isSame2(10,20));
        System.out.println("==========");
        System.out.println(isSame3(50,50));
    }
    public static boolean isSame(int a,int b){
        //方法一
        boolean same;
        if(a==b){
            same=true;
        }else{
            same=false;
        }
        return same;
    }
    //方法二
    public static boolean isSame1(int a,int b){
        boolean same=a==b?true:false;
        return same;
    }
    //方法三
    public static boolean isSame2(int a,int b){

         boolean same=a==b;
        return same;
    }
    //方法四
    public static  boolean isSame3(int a,int b){
        return a==b;
    }

}
--求出1-100的数字之和Demo02MethodSum.java
public class Demo02MethodSum {
    public static void main(String[] args) {
        int result=sumForHundred();
        System.out.println(result);
    }
    public static int sumForHundred(){
            int sum=0;
        for(int i=1;i<=100;i++){
            sum=sum+i;
        }
        return sum;
    }
}
--打印指定的次数的hello world Demo03MethodPrint.java
public class Demo03MethodPrint {
    public static void main(String[] args) {
            countPrint(3);
    }
    public static void countPrint(int a){
            int i=0;
        do{
            System.out.println("hello world");
            i++;
        }while(i!=a);
    }
}

方法的注意事项
1. 方法定义在类中，但是不能在方法中在定义方法，不能嵌套
2. 方法定义的前后顺序无所谓
3. 方法定义后不会执行，如果要执行请先调用，调用方法有三种方式，单独调用，输出调用，赋值调用，其中如果方法没有返回值只能使用单独调用，方法如果有返回值则三种调用方式都可以使用
4. 如果方法有返回值，则return必须写上，且return 后面的返回值类型必须和方法定义中的返回值类型一致
5. 对于一个void 没有返回值的类型的方法，不能写return 后面的数值，如果要写return，只能单独写return自己，return有两层含义，一是代表方法的执行结束，二是代表返回值，并把返回值传递给调用者，
6. 对于没有返回值的方法最后一个return可以不写，但是强烈建议，return都带上，虽然void 的无返回值，但是return可以代表方法的结束
7. 一个方法中可以有多个return语句，但是必须保证同时只有一个会被执行，因为执行完return语句后，也就代表了方法的执行结束
```
--Demo04MethodNotice.java
public class Demo04MethodNotice {
    public static void main(String[] args) {
        System.out.println(max(10, 20));
        System.out.println("=======");
        System.out.println(max1(10, 30));
        System.out.println("================");
        //System.out.println(aaa());
    }
    public static int max(int a, int b) {
        //方法一
        int max;
        if (a > b) {
            max = a;
        } else {
            max = b;
        }
        return max;
    }

    public static int max1(int a, int b) {
        if (a > b) {
            return a;//只能同时有意个return被执行
        } else {
            return b;
        }
    }
    public static void aaa(){
        //return 10错误写法
        //return 10;
        return;
    }
}
```

方法重载

对于功能类似，因为参数列表不一样，却要记住那么多的方法名太麻烦，所以引出了方法重载的概念，只需要记住唯一一个方法名称，就可以实现多个功能。具体使用哪个方法，要看参数的匹配。

--Demo01MethodOverload.java
public class Demo01MethodOverload {
    public static void main(String[] args) {
        System.out.println(sum(10,20));
        System.out.println(sum(10,20,20,40));
        System.out.println(sum(10,20,30));
    }
    //定义两个整数相加
    public static int sum(int a,int b){
        System.out.println("两个参数的方法被调用");
        return a+b;
    }
    public static int sum(int a,int b,int c){
        System.out.println("三个参数的方法被调用");
        return a+b+c;
    }
    public static int sum(int a,int b,int c,int d){
        System.out.println("四个参数的方法被调用");
        return a+b+c+d;
    }
}

方法重载的注意事项：

参数个数不同,参数的类型可以不同，但在返回值类型中需要进行强制类型转换，参数的多类型的顺序不同
方法名相同
方法重载中与参数的名称无关，只需要让系统知道传入不同的参数调用不同的方法即可
注意方法重载中不一定要返回值类型保持一样，只需要让系统知道如何调用每一个被重载的方法即可，与返回值的类型无关

注意方法重载中只是为不用书写很多功能类似的方法从而引出的，所以只需要你的方法名称相同，参数名称，返回值都可以不相同，重载方法的调用是根据参数个数不同来调用的。再次强调重载是在方法名称一样的前提下，参数列表不一样，参数列表不一样体现在参数个数不一样，参数类型不一样，参数一样但是参数类型的顺序不一样，注意参数名称不考虑。

--Demo001MethodOverload.java
public class Demo001MethodOverload {
    public static void main(String[] args) {

    }
    public static int sum(int a,int b){
        return a+b;
    }
    public static int sum(int x,int y,int z){
        return x+y;
    }
    /*public static int sum(int x,int y){
        return x+y;
    }*///对于方法名称一样，参数个数一样，知识参数的名称不一样，系统在调用的是后会不知到如何调用，从而产生错误
 /*   public static byte sum(int a,int b){
        return (byte) (a+b);
    }*///对于方法名一样，参数名称一样，则必须要求返,回值一样
    public static byte sum(int x,int y,int z,int j){
        return (byte) (x+y+z+j);
    }
    public static byte sum(int a,byte b){//这个是正确的重载写法
        return (byte) (a+b);
    }
    public static byte sum(byte a,int b){//这个是正确的重载写法
        return (byte) (a+b);
    }
}

方法重载的练习1

--Demo02MethodOverloadSame.java
public class Demo01MethodOverloadSame {
    public static void main(String[] args) {
        byte a=10,b=20;
        System.out.println(isSame(a,b));
        int c=10;int d=20;
        System.out.println(isSame(c,d));
        short e=10,f=10;
        System.out.println(isSame(e,f));
        long g=10L,h=10L;
        System.out.println(isSame(g,h));

    }
    public static boolean isSame(byte a,byte b){
        System.out.println("byte被调用了");
        return  a==b;
    }
    public static boolean isSame(int a,int b){
        System.out.println("int被调用了");
        if(a==b){
            return true;
        }else{
            return false;
        }
    }
    public static boolean isSame(short a,short b){
        System.out.println("short被调用了");
        boolean same=a==b?true:false;
        return same;
    }
    public static boolean isSame(long a,long b){
        System.out.println("long被调用了");
        boolean same;
        if(a==b){
            same=true;
        }else{
            same=false;
        }
        return same;
    }
}

--利用代码实现print重载
--Demo04MethodOverloadPrint.java

public class Demo04OverloadPrint {
    public static void main(String[] args) {
        myPrint(10);
        myPrint((byte)10);
        myPrint(10L);
        myPrint('a');
    }
    public static void myPrint(byte a){
        System.out.println("byte 方法被调用了");
        System.out.println(a);
    }
    public static void myPrint(short a){
        System.out.println("short方法被调用了");
        System.out.println(a);
    }
    public static void myPrint( int a){
        System.out.println("int方法被调用了");
        System.out.println(a);
    }
    public static void myPrint(long a){
        System.out.println("long被调用了");
        System.out.println(a);
    }
    public static void myPrint(char a){
        System.out.println("char被调用了");
        System.out.println(a);
    }
}

数组

数组的概念:

是一种容器，可以同时存放多个数据类型相同的数据

数组的特点:

数组中每个数据的类型必须要一样
数组是一种引用数据类型
数组的长度在程序运行期间不可改变

数组的创建

数组的初始化，在内存中创建一个数组，并且向其中赋予一定的默认值

常见的两种初始化方式

动态初始化：指定数组的长度(初始化时)

创建格式：
数据类型[] 数组名称=new 数据类型[数组长度]
从左到右依次解析
数据类型 代表数据中的每一个数据的数据类型都是这个
[]代表这是一个数组
数组名称 代表数组的名字
new 代表创建数组的动作
数组的长度，代表数组所能容纳的数据的长度，这也是动态创建数据的标识之一
--Demo01Array.java
public class Demo01Array {
    public static void main(String[] args) {
        int[] arrA=new int[300];//动态创建数组，可以容纳300个整型数据的数组
        double[] arrB=new double[30];//动态创建数组，可以容纳30个double类型的数据
        String[] arrC=new String[300];//动态创建数组，可以容纳300个字符串的数组
    }
}

静态初始化:指定内容，虽然静态初始化没有直接告诉长度，但是根据大括号的里面的元素内容，可以直接推算出来长度，所以说数组是一定具有长度的。

创建格式:
标准格式:
数据类型[] 数组名称=new 数据类型[]{内容}
public class Demo02Array {
    public static void main(String[] args) {
        int[] arrA= new int[]{1,2,3,4};
        String[] arrB=new String[]{"hello","java","world"};
    }
}
省略格式:
数据类型[] 数组名称={};
--Demo03Arr.java
public class Demo03Array {
    public static void main(String[] args) {
        //定义一个整型数组，存放数据5，6，7
        int [] arrA={5,6,7};
        //使用省略格式创建一个String类型的数组
        String[] arrB={"hello","Java","world"};
    }
}
静态初始化可以拆分为两个步骤，只局限与标准格式，创建数组的初始化如果是静态的就不能使用拆分
public class Demo03Array {
    public static void main(String[] args) {
        //定义一个整型数组，存放数据5，6，7
        int [] arrA={5,6,7};
        //使用省略格式创建一个String类型的数组
        String[] arrB={"hello","Java","world"};
        //静态创建数据可以拆分为两个基本步骤
        //定义一个double类型的数组，存放2.2，3.3，4.4
        double[] arrC;
        arrC=new double[]{2.2,3.3,4.4};
        String [] arrD;
        arrD=new String[]{"hello","world","java"};
        //动态创建数据的标准格式也可以拆分为两个
        //动态定义一个整型的数组,存放10个数据
        int [] arrE;
        arrE=new int[10];
    }
}
使用静态初始化和使用动态初始化的情况：
如果明确知道了数据的内容则使用静态初始化数组，如果不知道则使用动态数组的初始化，指明数组的长度

数组的使用

数组的打印，如果直接打印的是数组的名称，那么打印的是数组的内存地址哈希值

访问数组元素的格式，数组名称[索引值],注意索引值从0开始

public class Demo04ArrayUse {
    public static void main(String[] args) {
        //定义一个整型数组，存放数据10,20,30
        int[] arrA={10,20,30};
        System.out.println(arrA);//[I@1b6d3586 [代表的是数组，I代表整型
        System.out.println(arrA[0]);
        System.out.println(arrA[1]);
        System.out.println("=================");
        //定义一个double类型的素组
        double[] arrB=new double[]{2.2,3.3,4.4};//[D@4554617c [代表的是数组,D代表的是数据类型是double
        System.out.println(arrB);
        System.out.println(arrB[0]);
        System.out.println(arrB[1]);
        System.out.println(arrB[2]);
        //可以直接打印数组的值也可以将数组的值传递给变量，然后进行打印输出
        System.out.println("======================");
        double a=arrB[1];
        System.out.println(a);
    }
}

访问数组并进行赋值

使用动态初始化数组的时候，其中的元素将会有一个默认值，规则如下：如果是整数类型，则默认为0，如果是浮点类型，那么默认为0.0，如果是字符类型，则默认是’\u0000’,如果是布尔类型，则默认是false,如果是引用类型，那么默认为null
注意事项，静态数组也有默认值的过程，只不过系统自动马上将默认值替换了为大括号内的内容

--Demo05ArrayUse.java
public class Demo05ArrayUse {
    public static void main(String[] args) {
    	//动态创建整型数组
        int[] arrA=new int[3];
        System.out.println(arrA);
        System.out.println(arrA[0]);
        System.out.println(arrA[1]);
        System.out.println(arrA[2]);
        System.out.println("===============");
        //给数组的第三号元素赋值
        arrA[2]=123;
        System.out.println("===============");
        System.out.println(arrA[0]);
        System.out.println(arrA[1]);
        System.out.println(arrA[2]);
    }
}

java中的内存划分

java内存分为5个部分
- 栈(stack):存放的都是方法的局部变量，方法的运行一定要在栈中，局部变量指的是：方法的参数或者方法内部的变量,作用域，一旦超出作用域，立刻从栈内存中消失
- 堆(Heap)：凡是new出来的东西，都在堆中,堆内存里面的东西有一个地址值,16进制，堆内存里面的数据，都有默认值，规则:如果是整数: 默认为0，如果是浮点数默认为0.0 如果是字符默认为’\u0000’,如果是布尔默认为false 如果是引用类型默认为null
- 方法区(Method Area):存储.class相关信息，包含方法的信息
- 本地方法栈:(Native Method Stack):与操作系统相关
- 寄存器(pc Register)：与cpu相关

创建一个数组的java内存图(具体百度)

--Demo01ArrayOne.java
public class Demo01ArrayOne {
    public static void main(String[] args) {
        int[] array=new int[3];//动态初始化
        System.out.println(array);//地址值
        System.out.println(array[0]);//0
        System.out.println(array[1]);//0
        System.out.println(array[2]);//0
        System.out.println("========================");
        //改变数组当中的元素的内容
        array[1]=10;
        array[2]=20;
        System.out.println(array);
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
    }
}

创建两个数组的内存图(具体百度)

--Demo01ArrayTwo.java
public class Demo01ArrayTwo {
    public static void main(String[] args) {
        int[] arrayA=new int[3];//动态初始化
        System.out.println(arrayA);//地址值
        System.out.println(arrayA[0]);//0
        System.out.println(arrayA[1]);//0
        System.out.println(arrayA[2]);//0
        System.out.println("========================");
        //改变数组当中的元素的内容
        arrayA[1]=10;
        arrayA[2]=20;
        System.out.println(arrayA);
        System.out.println(arrayA[0]);
        System.out.println(arrayA[1]);
        System.out.println(arrayA[2]);
        System.out.println("========================");
        int[] arrayB=new int[3];//动态初始化
        System.out.println(arrayB);//地址值
        System.out.println(arrayB[0]);//0
        System.out.println(arrayB[1]);//0
        System.out.println(arrayB[2]);//0
        System.out.println("========================");
        //改变数组当中的元素的内容
        arrayB[1]=10;
        arrayB[2]=20;
        System.out.println(arrayB);
        System.out.println(arrayB[0]);
        System.out.println(arrayB[1]);
        System.out.println(arrayB[2]);
    }
}

两个数组引用指向同一个地址值

--Demo03ArraySame.java
public class Demo03ArraySame {
    public static void main(String[] args) {
        int[] arrayA=new int[3];//动态初始化
        System.out.println(arrayA);//地址值
        System.out.println(arrayA[0]);//0
        System.out.println(arrayA[1]);//0
        System.out.println(arrayA[2]);//0
        System.out.println("========================");
        //改变数组当中的元素的内容
        arrayA[1]=10;
        arrayA[2]=20;
        System.out.println(arrayA);
        System.out.println(arrayA[0]);
        System.out.println(arrayA[1]);
        System.out.println(arrayA[2]);
        System.out.println("========================");
        int[] arrayB=arrayA;//将arrayA的地址赋值给arrayB
        System.out.println(arrayB);//地址值
        System.out.println(arrayB[0]);//0
        System.out.println(arrayB[1]);//0
        System.out.println(arrayB[2]);//0
        System.out.println("========================");
        //改变数组当中的元素的内容
        arrayB[1]=10;
        arrayB[2]=20;
        System.out.println(arrayB);
        System.out.println(arrayB[0]);
        System.out.println(arrayB[1]);
        System.out.println(arrayB[2]);
    }
}

数组中常见的问题

数组索引越界

public class Demo01ArrayIndex {
    public static void main(String[] args) {
        int[] array={1,2,3};
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        //错误写法，并不存在3号索引
        //System.out.println(array[3]);
    }
}

数组的空指针异常(nullpointerexception),所有的引用型变量都可以赋值为一个null值，但是代表其中什么都没有，数组必须进行new初始化才能使用其中的元素，如果只是赋值了一个null,没有进行new创建，那么将会发生空指针异常，nullpointerException
```
public class Demo02ArrayNull {
    public static void main(String[] args) {
        int[] array=null;
        System.out.println(array[0]);
    }
}
```

获取数组的长度(存在与静态初始化的时候)
- 如何获取数组的长度，格式数组名称.length
- 数组一旦创建，在运行期间长度不可改变

  --Demo03ArrayLength.java
  public class Demo03ArrayLength {
      public static void main(String[] args) {
          int[] arr={1,2,3,4,56,5,6};//使用省略格式创建数组
          int[] arrA;
          arrA=new int[]{1,2,3,4,5,6,7,8,9};
          double[] arrB=new double[10];//动态创建浮点型的数组
          int[] arrC={1,2,3,4,5,6,7,8,9,10};
          System.out.println(arrC.length);
          System.out.println("=========================");
          int[] arrD;
          arrD=new int[3];//指向第一个数组,[I@1b6d3586
          System.out.println(arrD);
          arrD=new int[5];
          System.out.println(arrD);//指向第二个数组，[I@4554617c
      }
  }

遍历数组，将数组的每一个元素进行逐一，挨个儿处理，默认的处理方式就是打印输出

--Demo04Array.java
public class Demo04Array {
    public static void main(String[] args) {
        //遍历输出数组
        int[] arr=new int[]{1,2,3,4,5,6};
        for(int i=1;i<=arr.length;i++){
            System.out.println(arr[i-1]);
        }
        System.out.println("========================");
        double[] arrA={1.2,1.3,5.5,6.6};
        for (int i = 0; i < arrA.length; i++) {
            System.out.println(arrA[i]);
        }

    }
}
--小技巧arr.fori自动生成遍历输出数组

求出数组中的最大值，与数组中的最小值练习题一

--Demo06ArrayMax.java
public class Demo06ArrayMax {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5,20,30,50,10,90,110,200};
        int max=arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i]>max){
                max=arr[i];
            }
        }
        System.out.println("最大值是"+max);
    }
}
--Demo05ArrayMin.java
public class Demo05ArrayMin {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5,-1,20,30};
        int min=arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i]<min){
                min=arr[i];
            }
        }
        System.out.println("最小值是"+min);
    }
}

数组元素的反转，数组元素的反转其实是对称元素的交换

--Demo07ArrayReverse.java
public class Demo07ArrayReverse {
    public static void main(String[] args) {
        //在一个数组中进行数组元素的反转
        int[] arr={1,2,3,4,5,6};
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("=====================");
        for (int min =0,max=arr.length-1; min < max; min++,max--) {
            int temp;
            temp=arr[min];
            arr[min]=arr[max];
            arr[max]=temp;
        }
        System.out.println("==========================");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

    }
}

数组作为方法参数传递,当调用方法的时候，向方法的的小括号进行传参，传递进去的其实是数组的地址值。

--Demo01ArrayParam.java
public class Demo01ArrayParam {
    public static void main(String[] args) {
        int[] arr={10,20,30,40,50};
        printArray(arr);
    }
    /*
    * 方法三要素
    * 返回值类型
    * 方法名称
    * 参数列表
    * */
    public static void printArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

    }
}

数组作为方法的返回值，一个方法可以有0，1，多个参数，但是只能有0个或者1个返回值类型，不能有多个返回值

--Demo02ArrayReturn.java
public class Demo02ArrayReturn {
    public static void main(String[] args) {
        System.out.println("数组调用执行");
        int[] a=calculate(1,2,3);
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
        System.out.println("====================");
        System.out.println("第二个数组调用执行");
        System.out.println(calc(10,20,30));
    }
    public static int[] calculate(int a,int b,int c){
        int sum=a+b+c;
        int avg=sum/3;
        int[] arr={sum,avg};
        return arr;
    }
    public static int[] calc(int a,int b,int c){
        int sum=a+b+c;
        int avg=sum%3;
        int[] arr1=new int[2];
        System.out.println("calc"+arr1);
        arr1[0]=sum;
        arr1[1]=avg;
        return arr1;
    }
}

Adopat

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java基础知识回顾

java开发环境的搭建JREJAVA运行环境，包含JVM和运行时所需要的核心类库JDKjava程序开发工具包，包含JRE和开发人员所需要使用的工具JVMJAVA虚拟机，关于java虚拟机后续会通过一个详细笔记介绍java第一个程序Hell worldjava开发程序开发的三个步骤编写编译 javac.exe编译器运行 java.exe解释器--创建Hello...
复制链接

扫一扫

专栏目录