持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第20天，点击查看活动详情
一、Java简介
1、Java语言平台性介绍
编辑
2、JDK_JRE_JVM的组成和作用
JVM: Java虚拟机，是专门用来运行Java程序的,但是不能单独安装
JRE: Java运行环境，包含JVM(Java虚拟机,是专门用来运行Java程序的)和核心类库
JDK: Java开发工具包，包含JRE和开发工具
编辑
3、程序开发的步骤
1.HelloWorld
public class HelloWorld {
public static void main(String[] args){
System.out.println("HelloWorld");
}
}
编辑
二、注释
//这里是定义一个类,类的名字叫做Demo01ZhuShi,
//而且文件名必须和类的名字保持一模一样,public class 目前是固定写法,目前记住,后面讲解
public class Demo01ZhuShi {
/*
这里是定义main方法,public static void main(String[] args)是固定写法
main方法是程序的入口
*/
public static void main(String[] args){
/*
这是一个输出语句,用来向控制台输出显示内容的,
()中的""里面的内容会被输出显示到控制台上
*/
System.out.println("zhushi....");
}
}
三、变量
编辑
编辑
public class Demo03BianLiangNotice {
public static void main(String[] args){
//定义int变量a,并初始化
int a = 100;
System.out.println(a);
//错误: 不能在同一个区域({}),定义同名的变量
//int a = 200;
//System.out.println(a);
//定义int变量b,未赋值
int b;
//System.out.println(b);//错误: b中没有值,不能使用
b = 200;//把数字200赋值给变量b
System.out.println(b);
//long c = 6000000000;//错误: 6000000000(60亿)默认是int类型,但是大小已经远远超过int的取值范围(正负21亿)了
//System.out.println(c);
long d = 6000000000L;//6000000000L: 是long类型的数据
System.out.println(d);
//错误: 大萝卜不能直接放入小坑中
//float e = 6.6;//错误: 6.6默认是double类型,占8个字节,不能赋值给4个字节的float变量e
//System.out.println(e);
float f = 6.6F;//6.6F: 是float类型的数据
System.out.println(f);
}
}
四、Scanner类
在获取三个和尚中的最高身高案例中，身高数据如果由键盘录入，该怎样实现呢？
import java.util.Scanner;
public class ScannerTest {
public static void main(String[] args) {
//身高未知，采用键盘录入实现。首先导包，然后创建对象。
Scanner sc = new Scanner(System.in);
//键盘录入三个身高分别赋值给三个变量。
System.out.println("请输入第一个和尚的身高：");
int h1 = sc.nextInt();
System.out.println("请输入第二个和尚的身高：");
int h2 = sc.nextInt();
System.out.println("请输入第三个和尚的身高：");
int h3 = sc.nextInt();
//用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
int temp = h1 > h2 ? h1 : h2;
//用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
int max = temp > h3 ? temp : h3;
//输出结果。
System.out.println("这三个和尚中身高最高的是：" + max +"cm");
}
}
五、分支结构
5.1 IF
public class IfDemo {
public static void main(String[] args) {
System.out.println("开始");
//定义两个变量
int a = 10;
int b = 20;
//需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
if(a == b) {
System.out.println("a等于b");
} /
/需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于c
int c = 10;
if(a == c) {
System.out.println("a等于c");
}
System.out.println("结束");
}
}
5.2 循环结构 For
public static void main(String[] args) {
//需求：输出数据1-5
for(int i=1; i<=5; i++) {
System.out.println(i);
}
System.out.println("--------");
//需求：输出数据5-1
for(int i=5; i>=1; i--) {
System.out.println(i);
}
}
5.3 循环结构While
public static void main(String[] args) {
//for循环实现打印10次HelloWorld
for(int i=1; i<=10; i++) {
System.out.println("HelloWorld");
}
//定义初始化变量
int i = 1;
while(i<=10){
System.out.println("HelloWorld");
//步进
i++;
}
}
5.4 循环结构do-While
public static void main(String[] args) {
int x=1;
do {
System.out.println("HelloWorld");
x++;
} while(x<=10);
}
5.5循环跳转
5.5.1 break语句
使用场景：在选择结构switch语句中 在循环语句中 离开使用场景的存在是没有意义的
5.5.2 continue语句
使用场景：结束本次循环，继续下一次的循环 只能使用在循环语句中
六、随机数Random
//1. 导包
import java.util.Random;
public class Demo01_Random {
public static void main(String[] args) {
//2. 创建键盘录入数据的对象
Random r = new Random();
for(int i = 0; i < 3; i++){
//3. 随机生成一个数据
int number = r.nextInt(10);
//4. 输出数据
System.out.println("number:"+ number);
}
}
}
七、数组
7.1数组动态初始化
数组动态初始化就是只给定数组的长度，由系统给出默认初始化值。
格式：
数组存储的数据类型[ ] 数组名字 = new 数组存储的数据类型[长度];
int[] arr = new int[3];
7.2 数组静态初始化
在创建数组时，直接确定数组元素。
数据类型[ ] 数组名 = new 数据类型 [ ]{ 元素1,元素2,元素3... };
int[] arr = new int [ ]{ 1, 2, 3, 4, 5};
数据类型[ ] 数组名 = { 元素1,元素2,元素3... };
int[ ] arr = { 1, 2, 3, 4, 5};
7.3 数组原理内存图
JVM的内存划分：
编辑
7.3.1 一个数组内存图
public static void main(String[] args) {
int[] arr = new int[3];
System.out.println(arr);//[I@5f150435
}
编辑
7.3.2 两个数组内存图
public static void main(String[] args) {
int[] arr = new int[3];
int[] arr2 = new int[2];
System.out.println(arr);
System.out.println(arr2);
}
编辑
7.3.3 两个变量指向一个数组
public static void main(String[] args) {
// 定义数组，存储3个元素
int[] arr = new int[3];
//数组索引进行赋值
arr[0] = 5;
arr[1] = 6;
arr[2] = 7;
//输出3个索引上的元素值
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
//定义数组变量arr2，将arr的地址赋值给arr2
int[] arr2 = arr;
arr2[1] = 9;
System.out.println(arr[1]);
}
编辑
八、方法
8.1 无参数无返回值的方式
public class Demo04Method {
public static void main(String[] args) {
System.out.println("main....start....");
//调用方法
printOu();
printOu();
System.out.println("main....end....");
}
//定义一个方法，打印输出该方法内部的数据(方法内部定义的变量)是否是偶数
public static void printOu() {
int num = 18;
//判断num是否是偶数
if (num % 2 == 0) {
System.out.println(num + "是一个偶数");
} else {
System.out.println(num + "不是一个偶数");
}
return ;//结束方法,返回到方法的调用处,可以省略的
}
}
8.2 有参数无返回值的方式
public class Demo03MethodParams {
public static void main(String[] args) {
System.out.println("main...start...");
//调用方法
printOu(12);
printOu(15);
System.out.println("main...end...");
}
/*
定义一个方法，该方法接收一个int参数，方法内部打印输出该数据是否是偶数
三要素:
1.方法名称: printOu
2.参数列表: int num
3.返回值类型: void
*/
public static void printOu(int num) {
if (num % 2 == 0) {
System.out.println(num+"是一个偶数");
} else {
System.out.println(num+"不是一个偶数");
}
return ;
}
}
8.3 有参数有返回值的方式
public class Demo03MethodParams {
public static void main(String[] args) {
System.out.println("main...start...");
//调用方法
boolean result = isOu(15);
System.out.println("是否是偶数? "+result);
System.out.println("main...end...");
}
/*
定义一个方法，该方法接收一个int参数，方法内部判断是否是偶数
三要素:
1.方法名称: isOu
2.参数列表: int num
3.返回值类型: boolean
*/
public static boolean isOu(int num) {
if (num % 2 == 0) {
return true;
} else {
return false;
}
}
}
八、方法重载
方法重载：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数不相同，类型不同或者数量不同即可，与修饰符和返回值类型无关。
public class Demo01MethodProblem {
public static void main(String[] args) {
//打印/输出调用方法: 传递常量
System.out.println(getTwoIntNumSum(10,20));
System.out.println(getThreeIntNumSum(10,20,30));
System.out.println(getTwoDoubleNumSum(10.0,20.0));
System.out.println(getThreeDoubleNumSum(10.0,20.0,30.0));
}
//1.定义一个获取两个int数字之和的方法
public static int getTwoIntNumSum(int a, int b) {
return a + b;
}
//2.定义一个获取三个int数字之和的方法
public static int getThreeIntNumSum(int a, int b,int c) {
return a + b + c;
}
//3.定义一个获取两个double数字之和的方法
public static double getTwoDoubleNumSum(double a, double b) {
return a + b;
}
//4.定义一个获取三个double数字之和的方法
public static double getThreeDoubleNumSum(double a, double b,double c) {
return a + b + c;
}
}
九、方法的参数传递
9.1 方法参数传递
public class Demo01Var {
public static void main(String[] args) {
//定义int变量a,并初始化
int a = 20;
//定义int变量b,未初始化
int b;
b = a;//把变量a中的值赋值给变量b
System.out.println("a="+a);//20
System.out.println("b="+b);//20
b = b*10;
System.out.println("a="+a);//20
System.out.println("b="+b);//200
method();
//System.out.println(num);//错误: num是在method方法内部定义,只在method方法内部有效
}
public static void method(/*int m*/) {
int num = 100;
System.out.println(num);
//System.out.println(a);//错误: a是在main方法内部定义,只在main方法内部有效
}
}
编辑
9.2 基本类型作为方法参数传递
/*
基本数据类型作为方法参数
注意:
1.基本类型变量: 保存的是具体的数据值
2.基本类型变量作为形式参数,
形式参数的改变,不会影响实际参数
基本类型变量作为形式参数:
定义方法时,()中定义的参数属于基本类型
不会影响实际参数: 调用方法时,()中给出的参数
*/
public class Demo02BaseVar {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("ms...a="+a);//10
System.out.println("ms...b="+b);//20
//调用方法
change( a , b );
System.out.println("me...a="+a);//10
System.out.println("me...b="+b);//20
}
public static void change(int a, int b) {
System.out.println("cs...a="+a);//10
System.out.println("cs...b="+b);//20
a = a*10;
b = b*10;
System.out.println("ce...a="+a);//100
System.out.println("ce...b="+b);//200
}
}
编辑
编辑
9.3 引用类型作为方法参数传递
/*
引用数据类型作为方法参数
注意:
1.引用类型变量: 保存的是对象在堆内存空间的地址值,进行参数传递的时候,传递的也是地址值
2.引用类型变量作为形式参数,通过形式参数找到对应的堆内存空间,修改堆内存空间的内容之后,
通过实际参数看到的一定是修改后的堆内存空间的内容
引用类型作为形式参数,形式参数的改变,会影响实际参数
数组:
1.数组也是一种引用类型: 数组名称保存的也是数组在堆内存空间的地址值
2.数组作为方法参数或者返回值: 传递的都是数组在堆内存空间的地址值
*/
public class Demo03RefVar {
public static void main(String[] args) {
int[] arr = { 10 , 20 };
//System.out.println(arr);//数组名称: 保存数组在内存中的地址值[I@1540e19d
System.out.println("ms...arr[0]="+arr[0]);//10
System.out.println("ms...arr[1]="+arr[1]);//20
//调用方法
change( arr );
System.out.println("me...arr[0]="+arr[0]);//100
System.out.println("me...arr[1]="+arr[1]);//200
}
public static void change(int[] arr ) {
System.out.println("cs...arr[0]="+arr[0]);//10
System.out.println("cs...arr[1]="+arr[1]);//20
arr[0] = arr[0]*10;
arr[1] = arr[1]*10;
System.out.println("ce...arr[0]="+arr[0]);//100
System.out.println("ce...arr[1]="+arr[1]);//200
}
}
编辑