java基础语法

最新推荐文章于 2024-09-17 23:13:35 发布
最新推荐文章于 2024-09-17 23:13:35 发布
阅读量178 收藏
点赞数
分类专栏： java 文章标签： java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ryxiong728/article/details/115558345
版权

java基础语法

java注释

注释：程序在指定位置的说明性信息，不参与程序的运行逻辑

  • 当行注释：//注释信息
  • 多行注释：/*注释信息*/
  • 文档注释：/**注释信息*/
/*
	java程序基本组成单位是类，
	类的定义格式
		public class 类名 {
			...
		}
*/
public class HelloWrold{
	pulic static void main(String[] args) {
        // 输出语句
		System.out.println("hello world");
	}
}

java关键字

关键字：被java语言赋予了特定含义的单词

  • 关键字的字母全部小写
  • 常用编辑器对关键字，会有特殊颜色标记

image-20200629134332011

java常量

常量：程序运行中，其值不可以发生改变的量

常量类型说明距离
字符串常量双引号括起来的内容“Hello world”
整数常量不带小数的数字666
小数常量带小数的数字13.14
字符常量单引号括起来的内容‘A’
布尔常量布尔值，表示真假true, false
空常量一个特殊的值，空值null
public class ConstantDemo{
	public static void main(String[] args) {
		// 字符常量
		System.out.println("hello world");

		// 整数常量
		System.out.println("666");

		// 小数常量
		System.out.println("6.66");

		// 字符常量
		System.out.println('A');

		// 布尔常量
		System.out.println(true);

		// 空常量, 不能直接打印
		// System.out.println(null);
	}
}

java数据类型

存储单位：计算机存储设备最小心的单位：”位（bit）“，称为”比特位“，通常用小写字母”b“表示。而计算机中最小的存储单位为”字节（byte）“，通常大写字母”B“表示，字节是有连续的8个位组成。

数据类型：java是强类型语言，对于每一种数据都给出明确的数据类型，不同的数据类型也分配了不同的内存空间，所以他们表示的数据大小也不一样。

image-20200629161710373

数据类型内存占用和取值范围

image-20200629161816233

java变量

变量：在程序运行过程中，其值可以发生改变的量，用来指向内存中的具体区域。

变量三要素：1.变量名，2.数据类型，3.变量值

定义变量格式：数据类型 变量名 = 变量值；

int a = 10

变量取值格式：变量名

a

变量修改值：变量名 = 变量值;

a = 20;

示例：

public class VirableDemo{
	public static void main(String[] args) {
		// 变量定义
		int a = 10;
		// 输出变量
		System.out.println(a);
		
		// 修改变量
		a = 20
		// 输出变量
		System.out.println(a);
	}
}

使用变量注意的问题：

  1. 变量名不能重复
  2. 变量未赋值，不能使用
  3. long类型的变量定义时，为防止整数过大，整数后面加L
long l = 10000000000L;
  1. float类型的变量定义时，为防止格式不兼容，后面加F
float f = 13.14F;

java标识符

标识符：用于给类、方法、变量等命名的符号。

标识符定义规则：

  1. 由数字、字母、下划线(_)、美元符($)组成
  2. 不能以数字开头
  3. 不能是关键字
  4. 区分大小写

常见命名规则：

  1. 小驼峰：方法、变量
  • 标识符是一个单词时，首字母小写：name
  • 标识符有多个单词组成，第一个单词首字母小写，其他大写：firstName
  1. 大驼峰：类
  • 标识符为一个单词，首字母大写：Student
  • 标识符为多个单词组成，每个单词首字母大写：GoodStudent

java类型转换

1.自动类型转换：

把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量

public class ConversionDemo{
	public static void main(String[] args) {
		// 自动类型转换
		double a = 10;
		System.out.println(a);
        
        // 定义byte类型的便令
        byte b = 10;
        short s = b;
        int i = b;
        
        // 这种不可以
        // char c = b;
	}
}

2.强制类型转换

把一个表示护具范围大的数值或变量赋值给另一个表示范围小的变量

格式：目标数据类型变量名 = （目标数据类型）值或者变量；

会产生数据丢失，不建议使用

public class ConversionDemo{
	public static void main(String[] args) {  
        // 强制类型转换
        int k = (int)88.88;
        System.out.println(k);
	}
}

java运算符

算术运算符

运算符：对常量或者变量进行操作的符号

表达式：用运算法把常量或者变量连接起来符合java语法的式子可以称为表达式，不用运算法连接的表达式体现的是不同类型的表达式。

如：

public class OperatorDemo01{
	public static void main(String[] args) {  
        // 定义两个变量
        int a = 1;
        int b = 3;
        
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b);  // 商
        System.out.println(a % b);  // 余
        
        // 整数相除只能的到整数，要想的到小数，必须要有浮点数
        System.out.println(6.0 / 4);
	}
}

注意事项

  • 整数相除只能的到整数，要想的到小数，必须要有浮点数
字符的 + 操作

字符的 + 操作会拿字符在计算机底层对应的数值来进行计算

‘A’ - 65 A-Z连续

‘a’ - 97 a-z连续

‘0’ - 48 0-9连续

public class OperatorDemo02{
	public static void main(String[] args) {  
        // 定义两个变量
        int i = 10;
        char = 'A';
        
		c = 'A'; // 'A'的值是65
		c = 'a'; // 'a'的值97
		c = '0'; // '0'的值48
        
        // 整数相除只能的到整数，要想的到小数，必须要有浮点数
        System.out.println(i + c);

		// char ch = i + c;
        // char类型会被自动提升为int类型
        int j = i + c;
        System.out.println(j);
        
        // int d = 10 + 13.14;
        double d = 10 + 13.14;
	}
}

提升规则：

  • byte类型，short类型和char类型将被提升到int类型
  • 整个表达式的类型自动提升到表达式中最高等级操作同样的类型

字符串的 “+” 操作

public class OperatorDemo03 {
	public static void main(String[] args) {
		System.out.println("it" + "heima");
		System.out.println("itheima" + 666);
		System.out.println(666 + "itheima");
		
		System.out.println("itheima" + 6 + 66);
		System.out.println(1 + 99 + "itheima");
	}
}

当 “+” 操作中出现字符串时，这个 “+” 是字符串连接符，而不是算术运算符，如：“itheima” + 666

当 “+” 操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行 “+” 操作时，从左到右逐个执行，如：1 + 99 + “itheima”

赋值运算符

赋值运算符

符号作用说明
=赋值a=10，将10赋值给变量a
+=加后赋值a += b，a+b赋值给a
-=减后赋值a -= b，a-b赋值给a
*=乘后赋值a *= b，a*b的乘积赋值给a
/=除后赋值a /= b，a/b的商赋值给a
%=取余后赋值a %= b，a/b的余数赋值给a
public class OperatorDemo04 {
	public static void main(String[] args) {
		// 把10赋值给int
		int i = 10;
		System.out.println("i:" + i);
        
        // += 把左边和右边数据做加法，结果赋值给左边
        i += 20;  // 等价于 i = i + 20
        System.out.println("i:" + i);
        
        // 注意：扩展的赋值运算底层隐含了强制类型转换
        short s = 10;
        // s += 20;
        s = (short)(s + 20);
        System.out.println("s:" + s);
	}
}
自增运算符
符号作用说明
++自增变量值加1
–自减变量值减1

注意：

  • ++和–既可以放在变量的后面，也可以放在变量的前边。
  • 单独使用时，++和–无论是放在变量前面或者是变量后面，结果是一样的。
  • 参与操作时：如果放在变量前面，变量先参与操作，后做++或–；如果放在变量后面，变量先做++或–，后参与操作。

最常见的用法：单独使用

public class OperatorDemo05 {
	public static void main(String[] args) {
		// 把10赋值给int
		int i = 10;
		System.out.println("i:" + i);
        
        // 单独使用的时候，i++和++i是等效的
        i++;
        System.out.println("i:" + i);
        ++i;
        System.out.println("i:" + i);
        
        // 参与操作时
        int i = 10;
        int j = i++;
        System.out.println("i:" + i);
        System.out.println("j:" + j);
        
        int i = 10;
        int j = ++i;
        System.out.println("i:" + i);
        System.out.println("j:" + j);
	}
}
关系运算符

常见关系运算符

符号说明
==a==b，判断a和b是否相等，成立true，否则false
!=a==b，判断a和b是否不相等，成立true，否则false
>a>b，判断a是否大于b，成立true，否则false
>=a>=b，判断a是否大于等于b，成立true，否则false
<a<b，判断a是否小于b，成立true，否则false
<=a<=b，判断a是否小于等于b，成立true，否则false

示例

public class OperatorDemo06 {
	public static void main(String[] args) {
		// 把10赋值给int
		int i = 10;
		int j = 20;
		int k = 10;
        // 比较
		System.out.println(i == j);
		System.out.println(i != j);
		System.out.println(i > j);
		System.out.println(i >= j);
		System.out.println(i < j);
		System.out.println(i <= j);

	}
}
逻辑运算符

逻辑运算：用来连接关系表达式的运算符，也可以连接布尔类型和常量。

符号作用说明
&逻辑与a&b，ab都为True，则为true，否则false
|逻辑或a|b，ab任意为True，则为true，否则false
^逻辑异或a^b，a和b结果不同为true，否则为false
!逻辑非!a，结果和a相反

示例

public class OperatorDemo07 {
	public static void main(String[] args) {
		// 把10赋值给int
		int i = 10;
		int j = 20;
		int k = 30;
        // & 有false则false
        System.out.println((i > j) & (i > k));
        System.out.println((i < j) & (i > k));
        System.out.println((i > j) & (i < k));
        System.out.println((i < j) & (i < k));
        
        // | 有true则ture
        System.out.println((i > j) | (i > k));
        System.out.println((i < j) | (i > k));
        System.out.println((i > j) | (i < k));
        System.out.println((i < j) | (i < k));
        
        // ^ 相同为false，不同为true
        System.out.println((i > j) ^ (i > k));
        System.out.println((i < j) ^ (i > k));
        System.out.println((i > j) ^ (i < k));
        System.out.println((i < j) ^ (i < k));
        
        // ! 相反
        System.out.println((i > j));
        System.out.println(!(i < j));

	}
}

短路逻辑运算符

符号作用说明
&&短路与作用和&相同，但是有短路效果，前边为false，则为false，不再判断
||短路或作用和|相同，但是有短路效果，前边为true，则为true，不再判断

示例

public class OperatorDemo08 {
	public static void main(String[] args) {
		// 把10赋值给int
		int i = 10;
		int j = 20;
		int k = 30;
        // && 有false则false
        System.out.println((i > j) && (i > k));
        System.out.println((i < j) && (i > k));
        System.out.println((i > j) && (i < k));
        System.out.println((i < j) && (i < k));
        
        // || 有true则ture
        System.out.println((i > j) || (i > k));
        System.out.println((i < j) || (i > k));
        System.out.println((i > j) || (i < k));
        System.out.println((i < j) || (i < k));
        
        // &&和&
        System.out.println((i++ > 100) & (j++ > 100));
        // System.out.println((i++ > 100) && (j++ > 100));
        System.out.println("i:" + i);
        System.out.println("j:" + j);
	}
}

注意事项：

  • 逻辑与&，无论左边真假，右边都要执行

    短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。

  • 逻辑或|，无论左边真假，右边都要执行

    短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。

三元运算符

格式：关系表达式?表达式1: 表达式2;

范例：a > b ? a: b

public class OperatorDemo09 {
	public static void main(string[] args) {
		// 定义两个变量
		int a = 10;
		int b = 20;
		
		// 获取两个数据中的较大值
		int max = a > b ? a: b;
		// 输出结果
		System.out.println("max:" + max)
	}
}

java数据输入

Scanner使用基本步骤

/*
	数据导入
		导包：
			import java.util.Scanner;
		创建对象：
			Scanner sc = new Scanner(System.in);
		接受数据：
			int x = sc.nextInt();
*/
import java.util.Scanner;
public class ScannerDemo {
	public static void main(String[] args) {
		// 创建对象
		Scanner sc = new Scanner(System.in);
		
		// 接收数据
		int x = sc.nextInt();
		
		// 输出数据
		System.out.println("x:" + x);
	}
}

java流程控制

流程控制语句分类

  • 顺序结构
  • 分支结构（if, switch)
  • 循环结构（for, while, do … while）
顺序结构

最简单的基本流程控制，按照代码先后顺序，一次执行。

public class OrderDemo {
	public static void main(string[] args) {
		System.out.println("开始");
		System.out.println("语句A");
		System.out.println("语句B");
		System.out.println("结束");
	}
}
if分支结构

1.单分支格式

if (关系表达式) {
	语句体;
}

执行流程：计算关系表达式，值为true，执行与语句体，否则不执行语句体，继续执行后面语句。

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");
		};
		if (a != b) {
			System.out.println("a不等于b");
		};
		System.out.println("结束");
	}
}

2.二分支格式

if (关系表达式) {
	语句体1;
} else {
	语句体2;
}

image-20200629233927569

执行流程：

  1. 计算关系表达式的值
  2. 值为true，执行与语句体1
  3. 否则执行语句体2
  4. 继续执行后面语句。
public class IfDemo02 {
	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");
		} else {
			System.out.println("a不等于b");
		};
		System.out.println("结束");
	}
}

3.多分支格式

if (关系表达式1) {
	语句体1;
} else if (关系表达式2) {
	语句体2;
}
...
else {
	语句体n+1;
}

执行流程：

  1. 计算关系表达式1的值；
  2. 值为true，执行与语句体1；值为false就计算关系表达式2的值；
  3. 值为true，执行与语句体2；值为false就计算关系表达式3的值；
  4. …
  5. 如果没有任何关系表达式为True，则执行语句体n+1；
import java.util.Scanner;
public class IfDemo03 {
	public static void main(String[] args) {
		System.out.println("开始");
		// 输入一个星期数，对应星期一、星期二、星期三、...、星期日
		Scanner sc = new Scanner(System.in);
		System.out.println("输入一个星期数(1~7):");
		int week = sc.nextInt();
		
		if (week == 1) {
			System.out.println("星期一");
		} else if (week == 2) {
			System.out.println("星期二");
		} else if (week == 3) {
			System.out.println("星期三");
		} else if (week == 4) {
			System.out.println("星期四");
		} else if (week == 5) {
			System.out.println("星期五");
		} else if (week == 6) {
			System.out.println("星期六");
		} else {
			System.out.println("星期日");
		};
		System.out.println("结束");
	}
}
switch语句

流程格式

switch (表达式) {
	case 值1:
		语句体1;
		break;
	case 值2:
		语句体2;
		break;
	...
	default:
		语句体n+1;
		[break;]
}

说明：

  • 表达式：取值为byte、short、int、char、JDK5以后可以是枚举，JDK7以后可以使String。
  • case：后面跟的是要和表达式进行比较的值
  • break：表示中断，结束的意思，用来结束switch语句
  • default：表示所有情况都不匹配的时候，就执行该处的内容，和if-else语句相似

执行流程：

  1. 计算表达式的值
  2. 依次和case后面的值进行比较，如果有对应的值，就会执行相应的语句，执行过程中，遇到break会结束。
  3. 如果所有case后面的值和表达式的值不匹配，就会执行default里面的语句体，然后程序结束。

image-20200630085948630


import java.util.Scanner;

public class SwitchDemo{
	public static void main(String[] args) {  
        System.out.println("开始");
		// 输入一个星期数,对应输出星期一,...星期日
		Scanner sc = new Scanner(System.in)

		System.out.println("请输入一个星期数(1-7):")
		int week = sc.nextInt();
		switch (week) {
			case 1:
				System.out.println("星期一");
				break;
			case 2:
				System.out.println("星期二");
				break;
			case 3:
				System.out.println("星期三");
				break;
			case 4:
				System.out.println("星期四");
				break;
			case 5:
				System.out.println("星期五");
				break;
			case 6:
				System.out.println("星期六");
				break;
			case 7:
				System.out.println("星期日");
				break;
			default:
				System.out.println("输入星期数有误");
				break;
		}

		System.out.println("结束")
	}
}
for循环语句

循环结构组成：

  • 初始化条件：表示循环开始时的起始状态
  • 条件判断语句：用于判断循环是否反复执行的条件
  • 循环体语句：循环反复执行的内容
  • 条件控制语句：循环中每次变化的内容，控制循环体是否执行下去

格式

for (初始化语句; 条件判断语句; 条件控制语句) {
	循环体语句;
}

流程：

  1. 执行初始化语句
  2. 执行条件判断语句：结果是false，循环结束；结果是true，继续执行
  3. 执行循环体语句
  4. 执行条件控制语句
  5. 回到2重复执行

image-20200630091233564

public class ForDemo{
	public static void main(String[] args) {  
		// 输出5次"HelloWrold"
		for (int i=1; i<=5; i++) {
			System.out.println("HelloWrold");
		}
	}
}
while循环语句

完整格式

初始化语句;
while (条件判断语句) {
	循环体语句;
	条件控制语句;
}

执行流程：

  1. 执行初始化语句；
  2. 执行条件判断语句：结果是false，循环结束；结果是true，继续执行；
  3. 执行循环体语句；
  4. 执行条件控制语句；
  5. 回到2重复执行；

image-20200630120158886

public class WhileDemo01 {
	public static void main(String[] args) {  
		// for实现,输出5次"HelloWrold"
		for (int i=1; i<=5; i++) {
			System.out.println("HelloWrold");
		}

		// while实现,输出5次"HelloWrold"
		int j = 1;
		while (j <= 5) {
			System.out.println("HelloWorld");
			j++;
		}
	}
}
do…while循环语句

基本格式

do {
	循环体语句;
} while (条件判断语句);

完整格式

初始化语句;
do {
	循环体语句;
	条件控制语句;
} while (条件判断语句);

执行流程：

  1. 执行初始化语句；
  2. 执行循环体语句；
  3. 执行条件控制语句；
  4. 执行条件判断语句：结果是false，循环结束；结果是true，继续执行；
  5. 回到2重复执行；
image-20200630124406312 
public class WhileDemo02 {
	public static void main(String[] args) {  
		// for实现,输出5次"HelloWrold"
		for (int i=1; i<=5; i++) {
			System.out.println("HelloWrold");
		}

		// while实现,输出5次"HelloWrold"
		int j = 1;
		do {
			System.out.println("HelloWorld");
			j++;
		} while (j <= 5);
		
	}
}
三种循环的区别

循环区别：

  • for和while是先判断条件是否成立，在决定是否执行
  • do…while先执行一次，在判断是否成立，是否继续执行

for和while区别：

  • 条件语句控制的自增变量，在for循环结束后，外部不能再次访问到
  • 条件语句控制的自增变量，不属于while语法结构，while循环结束后，还可以继续使用
public class LoopTest {
	public static void main(String[] args) {
		// 区别一:  
		// for循环
		for (int i=3; i<3; i++) {
			System.out.println("i love java");
		}

		// while循环
		int j = 3;
		while (j < 3) {
			System.out.println("j love java");
			j++;
		}

		// do...while循环
		int k = 3;
		do {
			System.out.println("k love java");
			j++;
		} while (k < 3);

		// 区别2:
		// for循环
		for (int i=3; i<3; i++) {
			System.out.println("i love java");
		}
		// System.out.println(i);  // 不能再使用,会报错

		// while循环
		int j = 3;
		while (j < 3) {
			System.out.println("j love java");
			j++;
		}
		System.out.println(j);  // 可以正常使用
	}
}

三种死循环写法

while死循环是最常用的

public class LoopTest01 {
	public static void main(String[] args) {
		// 死循环
		for (;;) {
			System.out.println("for");
		}

		while (true) {
			System.out.println("while");
		}

		do {
			System.out.println("do...while");
		} while (true);
	}
}
跳转控制语句

continue：循环中，基于条件控制，跳过某次循环体内容的执行，继续下次的执行

break：循环中，基于条件控制，终止循环体内容的执行，结束当前整个循环。

public class ControlDemo {
	public static void main(String[] args) {
		for (int i=1; i<=5; i++) {
			// continue
			break
			System.out.println(i)
		}
	}
}
循环嵌套

分支语句中包含分支语句称为分支嵌套

循环语句中包含循环语句称为循环嵌套

public class LootNestDemo {
	public static void main(String[] args) {
		// for循环嵌套
		for (int hour=0; i<=3; i++) {
			for (int minute=0; minute<=3; minute++) {
				System.out.println(hour + "时" + minute + "分");
			}
			System.out.println("---------------")
		}
	}
}

Random模块

Random模块：产生一个随机数

使用步骤：

// 导入包
import java.util.Random
// 创建对象
Random r = new Random();
// 获取随机数
int number = r.nextInt(10); // 获取数据的范围: [0,10)

示例

import java.util.Random
public class RandomDemo {
	public static void main(String[] args) {
		// 创建对象
        Random r = new Random();
        // 获取随机数
        int number = r.nextInt(10); // 获取数据的范围: [0,10)
		System.out.println(number);
        
        // 获取一个1~100之间的随机数
        int x = r.nextInt(100) + 1;
        System.out.println(x);
		}
	}
}
大数据与数据分析
关注
专栏目录
Java入门之~Java基础语法
Ara-追着风跑
03-12 7271
Java入门之基础语法篇，收藏学起来
java基础学习入门学习第五天——深入理解java运算符（完整版）
QZP51ZX的博客
09-28 292
java基础知识之深入理解运算符 2.9java运算符 2.9.1什么是运算符？ 定义：运算符是一种特殊符号，用以表示数据的运算，赋值和比较且不同的运算符用来完成不同的运算 2.9.2为什么要用运算符？ 运算符和表达式是java程序的基本组成元素，java语言使用运算符将一个或者多个操作数连缀在一起成执行语句，形成表达式。 表示式是由运算符和操作数按一定语法规则组成的符号序列，表达式经过四则...
Java基础语法
热门推荐
terence的博客
03-27 9万+
1. Java概述 1.1 Java语言发展史 语言:人与人交流沟通的表达方式 计算机语言:人与计算机之间进行信息交流沟通的一种特殊语言 Java语言是美国Sun公司(Stanford University Network)在1995年推出的计算机语言 Java之父:詹姆斯·高斯林(James Gosling) 2009年，Sun公司被甲骨文公司收购，所以我们现在访问oracle官网即可:https://www.oracle.com 当前，我们课程使用的JDK版本:11.0 1.2 Java语言跨平台原理
Java基础篇 | Java基础语法
分享思想，留下痕迹。
05-31 1万+
Java以前自学过一写，现在工作了，时间太久有一些知识都遗忘了，今天开始就更新Java了，想着把之前的Java基础知识捡起来；从最基础的开始，打好Java基础，便于以后复习。也欢迎大家跟我一起复习。Java中，字面量指的是在程序中直接使用的数据，字面量是Java中最基本的表达式，不需要进行计算或转换，直接使用即可。基本数据类型整数类型：包括byteshortint和long四种类型，用于表示整数。浮点类型：包括float和double两种类型，用于表示带小数点的数值。boolean。
JAVA基础语法
m0_64253261的博客
10-25 2837
JAVA基础语法
Java基础语法结构
Miss Z的博客
10-04 1100
Java语法结构分为顺序结构、选择结构和循环结构
java基础语法（精简版）
qq_52857122的博客
03-21 5394
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、运算符 算数运算符 赋值运算符 关系运算符（比较运算符） 逻辑运算符 三元运算符 二、条件控制语句 switch语句 流程控制语句 if语句 三、循环 四、随机数 五、数组 六、二维数组 总结 一、运算符 1、算数运算符 首先知道运算符和表达式： ·运算符：对常量或者进行操作的符号。 ...
Java基础语法——数组
qq_52519008的博客
05-08 1757
每日正能量 世上还有很多美好的事物等着你，别抱怨更不要放弃，所以你要内心温柔，安静努力。 1. 首先我们引入几个问题： 1.1 什么是数组？ 数组就是具有相同数据类型且按一定次序排列的一组变量的集合体。即用一个变量名表示一组数据。 1.2什么是数组元素？ 构成一个数组的每一个数据称为数组元素。 1.3什么是数组下标 各元素通过下标来区分。下标表明了数组元素在数组中的位置。在一个数组中，数组下标是用整数表示的，从0开始，...
【Java】基础语法介绍
最新发布
Eristic0618的博客
09-17 1728
本篇文章围绕Java的基础语法展开讲解，包含关键字、输入输出、数据类型、运算符、分支循环、类和对象、接口、数组等内容
笔记01-Java基础语法
terence的博客
06-27 4万+
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
Java基础语法练习.zip
08-12
这个"Java基础语法练习.zip"文件显然旨在帮助初学者巩固和理解Java的基础知识。下面，我们将详细探讨其中涉及到的一些核心概念。 1. **打印三角形**： 在Java中，打印三角形通常涉及到循环和字符串拼接。例如，...
java基础语法练习题.zip
06-28
Java基础语法是编程入门的关键，这些练习题涵盖了Java语言的核心概念，旨在帮助初学者巩固学习成果。以下是对每个文件内容的详细解读： 1. **"1.java运行环境.docx"**：这部分内容会介绍如何在计算机上安装Java ...
08_Java基础语法_第8天（Eclipse）_讲义
02-16
Java基础语法是编程学习的重要部分，尤其是在使用Eclipse这样的集成开发环境(IDE)时，它能极大地提升开发效率。Eclipse是一款广泛使用的开源Java IDE，适用于编写Java应用程序和其他基于Java的技术，如Spring或...
Java基础语法)教案
04-05
### Java基础语法教案知识点解析 #### 一、Java开发环境搭建 **1.1 Java语言概述** - **视频摘要:** 引入Java语言的历史和发展，包括它的起源、发展历程及其广泛的应用场景。通过介绍Java的特点（如面向对象、跨...
IDEA开发工具
饶一熊的博客
04-09 3336
IDEA开发工具 IDEA概述和安装 IDEA全称IntelliJ IDEA，java语言开发的集成环境，业界公认java程序开发最好的工具。 集成环境：把代码编写、编译、执行、调试等多种功能综合到一起的开发工具、 下载和安装 下载：https://www.jetbrains.com/idea/download/other.html 安装：傻瓜式默认安装，window建议更改路径 IDEA基本配置 编写一个helloworld步骤 创建一个空目录（javaSE_code) 创建一个模块（idea_demo
java输入流详解
饶一熊的博客
03-11 925
java输入流详解 java中提供了很多中输入流对象, 如FileInputStream, BufferedInputStream, InputStreamReader, BufferedReader.很多初学者会被绕的晕头转向. 其实核心用来读取数据的就是FileInputStream, 其他的都是java对FileInputStream的封装, 体现的是装饰者设计思想. FileInputStream FileInputStream 字节流: 是真正读取数据的对象, 在读取是只能通过一个字节一个字节的读
常用设计模式
饶一熊的博客
05-06 331
常用的几个设计模式 设计模式三大类 参考文章：https://blog.csdn.net/gududedabai/article/details/81989196 创建性模式： 单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式 结构型模式： 适配器模式、桥接模式、装饰者模式、组合模式、外观模式、享元模式、代理模式 行为型模式： 模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、接解释器模式、状态模式、策略模式、职责链模式、访问者模式。 OOP七大法则 开闭原则：对扩展开放，对修改
Java数组模块
饶一熊的博客
04-09 186
Java数组模块 1.数组定义 数组(array)是一种用于存储多个相同类型数据的存储格式 数组两种定义格式： 数据类型[] 变量名 定义类一个int类型的数组变量，变量名为arr，推荐使用 int[] arr 数据类型 变量名[] int arr[] 2.数组初始化 java数组必须先初始化才能使用 初始化：为数组中的数组元素分配内存空间，为每个数组元素赋值 数组初始化方法 动态初始化：初始化时只指定数组长度，由系统为数组分配初始值 格式：数据类型[] 变量名 = new 数据类型[数组
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值