helloworld
class HelloWorld {
public static void main(String[] args) {
System.out.println("helloworld");
}
}
注释
//注释：用于解释说明程序的文字
/*
注释的分类：
单行注释 一般用于解释说明单行程序
格式是：//注释文字
多行注释 一般用于解释说明多行程序
格式是：
文档注释 一般是对类或者方法进行说明，被javadoc工具解析生产一个文档说明书。
格式是：
*/
//注意：多行注释不能嵌套写，而单行注释可以。
//这是我的学生案例
//class是java中用来定义类的
//定义类的格式是：class 类名
/*
这是我的学生案例
class是java中用来定义类的
定义类的格式是：class 类名
*/
/** */
class Student {
public static void main(String[] args) {
System.out.println("我是学生");
}
}
带注释的helloworld
/*
需求：我要完成HelloWorld案例
分析：
A:java语言最基本的单位是类，所以我们首先要定义一个类
B:java程序要想能够独立运行，必须有主方法
C:如果想要程序有输出，必须有输出语句
步骤：
A:定义类的格式
class 类名 {
//类体
}
B:主方法的格式
public static void main(String[] args) {
//方法体
}
C:输出语句的格式
System.out.println("这里的内容是可以改");
最后把我们的思想用代码给体现出来
*/
//这是我的带注释的HelloWorld案例
//class用来定义类
class HelloWorld {
/*
这是main方法
main方法是程序的入口
jvm会自动调用main方法
*/
public static void main(String[] args) {
//这是输出语句
System.out.println("HelloWorld");
}
}
/*
注释的作用：
A:解释说明程序，提高程序的阅读性
B:可以帮助我们调试程序
*/
class Demo {
public static void main(String[] args) {
System.out.println("HelloWorld");
System.out.print("我爱林青霞"); //println与print区别在于换行与非换行
System.out.print("我爱Java");
System.out.print("我爱张瑜");
}
}
关键字
/*
关键字：被Java语言赋予特定含义的单词
关键字的特点：关键字都是小写的
关键字注意事项
A:goto和const作为保留字存在,目前并不使用
B:类似Editplus这样的高级记事本,针对关键字有特殊的颜色标记，非常直观
*/
class KeyWord {
public static void main(String[] args) {
System.out.println("HelloWorld");
}
}
标识符
/*
标识符：就是给类,接口,方法,变量等起名字时使用的字符序列(字符串)
组成规则：
A:英文字母大小写
B:数字
C:_和$
注意事项：
A:不能以数字开头
B:不能是Java中的关键字
C:区分大小写
Student,student 这是两个名称
常见的命名规则：见名知意
A:包 其实就是文件夹,用于解决相同类名问题
全部小写
单级：com
多级：cn.itcast
B:类或者接口
一个单词：首字母大写
Student,Person,Teacher
多个单词：每个单词的首字母大写
HelloWorld,MyName,NameDemo
C:方法或者变量
一个单词：全部小写
name,age,show()
多个单词：从第二个单词开始，每个单词首字母大写
myName,showAllStudentNames()
D:常量
一个单词：全部大写
AGE
多个单词：每个单词都大写，用_连接
STUDENT_MAX_AGE
*/
class NameDemo {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
常量
/*
常量：在程序执行的过程中其值不可以发生改变
举例：π
分类：
A:字面值常量
1，12.5
B:自定义常量(面向对象部分讲解)
字面值常量分类：
A:字符串常量 用""括起来的内容 String
B:整数常量 所有的整数数据 int
C:小数常量 所有的带小数的数据 float/double
D:字符常量 用单引号括起来的内容 char
E:布尔常量 只有两个值：true和false blolean
F:空常量 null(数组部分去讲解) null
*/
class ConstantDemo {
public static void main(String[] args) {
//字符串常量
System.out.println("HelloWorld");
//整数常量
System.out.println(100);
//小数常量
System.out.println(12.345);
//字符常量
System.out.println('A');
//下面的是错误的
//System.out.println('BC');//此条错误
System.out.println('1');
//布尔常量
System.out.println(true);
System.out.println(false);
}
}
进制转换
/*
二进制
由0,1组成。以0b开头
八进制
由0,1,…7组成。以0开头
十进制
由0,1,…9组成。整数默认是十进制的
十六进制
由0,1,…9,a,b,c,d,e,f(大小写均可)。以0x开头
*/
class JinZhiDemo {
public static void main(String[] args) {
System.out.println(0b100);//4
System.out.println(0100);//64
System.out.println(100);//100
System.out.println(0x100);//256
}
}
变量
/*
成员变量和局部变量的区别：
A:在类中的位置不同
成员变量 类中方法外
局部变量 方法内或者方法声明上
B:在内存中的位置不同
成员变量 堆内存
局部变量 栈内存
C:生命周期不同
成员变量 随着对象的存在而存在，随着对象的消失而消失
局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
D:初始化值不同
成员变量 有默认的初始化值
局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。
注意：
如果有同名的变量，一般会采用就近原则。
*/
class VariableDemo {
//成员变量 堆内存
int x;
public static void main(String[] args) {
//局部变量 栈内存
int y;
y = 0; //如果不赋值,将报错,成员变量有默认初始值.
System.out.println(y);
VariableDemo vd = new VariableDemo();
System.out.println(vd.x);
}
}
数据类型
/*
为了更好的表达现实世界的事物，Java针对不同的事物提供了不同的数据类型。
数据类型：
基本类型：4类8种
引用类型：类，接口，数组。(后面讲)
基本类型:
整数： 占用的内存空间
byte 1字节
01111111
10000000(1既表示符号位，又表示数值 -128)
short 2字节
int 4字节
long 8字节
浮点数：
float 4字节
double 8字节
字符：
char 2字节
布尔：
boolean 未知。1字节
面试题：
Java中字符可以存储一个汉字吗?
可以。因为Java语言采用的是unicode编码，
而unicode编码的每个字符是两个字节，
所以，java中的字符可以存储一个汉字。
注意：
整数默认是int类型
浮点数默认是double类型
long类型的变量，要加l或者L。
float类型的变量，要加f或者F。
在同一对{}里面，是不能有同名的变量。
*/
class DataType {
public static void main(String[] args) {
//定义变量的格式：
//数据类型 变量名 = 初始化值;
//定义byte类型的变量
byte b = 1;
System.out.println(1);
System.out.println(b);
//定义short类型的变量
short s = 100;
System.out.println(s);
//定义int类型的变量
int i = 100000;
System.out.println(i);
//报错
//int j = 2147483648;
//System.out.println(j);
//定义long类型的变量
long l = 2147483648L;
System.out.println(l);
//定义float类型的变量
float f = 12.34F;
System.out.println(f);
//定义double类型的变量
double d = 23.56;
System.out.println(d);
//定义char类型的变量
char ch = 'a';
System.out.println(ch);
//定义boolean类型的变量
boolean flag = true;
System.out.println(flag);
}
}
类型转换
/*
+是一个运算符, 我们应该能够看懂，做数据的加法。
参与运算的数据，要求类型一致。
boolean类型不能转换为其他的数据类型。
隐式转换：
A:byte,short,char-->int-->long-->float-->double
B:byte,short,char相互之间不转换，他们参与运算首先转换为int类型
*/
class DataTypeDemo {
public static void main(String[] args) {
//类型一样的数据
int a = 10;
int b = 20;
System.out.println(a + b);
int c = a + b;
System.out.println(c);
System.out.println("--------------");
//定义变量
byte by = 3;
int i = 4;
System.out.println(by + i);
int j = by + i;
System.out.println(j);
}
}
/*
强制转换:从大到小，不建议使用，因为可能有精度的丢失。
目标类型 变量名=(目标类型)(被转换的数据);
*/
class DataTypeDemo2 {
public static void main(String[] args) {
//定义变量
byte by = 3;
int i = 4;
byte bb = (byte)(by + i);
System.out.println(bb);
}
}
/*
+:做加法操作
A:针对数据操作
B:针对字符进行做+
ASCII码表
'0' 48
'A' 65
'a' 97
C:针对字符串进行做+
在字符串的操作中，叫字符串连接符
*/
class DataTypeDemo3 {
public static void main(String[] args) {
System.out.println('a');
System.out.println('a'+1);
System.out.println('A'+0);
System.out.println('0'+0);
System.out.println("-----------");
System.out.println('a'+'b');
System.out.println("a"+"b");
System.out.println("hello"+'a'+1); //左边字符串，往后拼的都是字符串
System.out.println('a'+1+"hello");
System.out.println("5+5="+5+5);
System.out.println(5+5+"=5+5");
}
}
/*
byte b1=3,b2=4,b;
b=b1+b2;
b=3+4;
哪句是编译失败的呢？为什么呢？
b=b1+b2;
原因：
变量相加，它首先提示类型，再做操作。
常量相加，它先做操作，然后判断结果是否在左边的范围内容，如果在就不报错。如果不在，报错。
*/
class DataTypeTest {
public static void main(String[] args) {
byte b1=3,b2=4,b;
//b = b1+b2; //右边类型自动提升
b = 3+4;
}
}
/*
byte b = 130;有没有问题?如果我想让赋值正确，可以怎么做?结果是多少呢?
*/
class DataTypeTest2 {
public static void main(String[] args) {
//byte b = 130;
//解决方案
//方案1
//int a = 130;
//方案2
byte b = (byte) 130;
System.out.println(b);
}
}
/*
十进制：130
A:第一步，先把十进制转换为二进制
二进制：000000000 000000000 000000000 100000010
由于此二进制是一个正数，所以，补码也是000000000 000000000 000000000 100000010。
B:做强制类型转换
二进制：000000000 000000000 000000000 100000010
截取后就变成了：100000010
C:操作后的数据是补码，你看到的是原码
符号位 数值位
补码： 1 00000010
反码： 1 00000001
原码： 1 11111110
*/
class DataTypeTest3 {
public static void main(String[] args) {
byte b = (byte)300;
System.out.println(b);
System.out.println((byte)127);
System.out.println((byte)128);
System.out.println((byte)129);
System.out.println((byte)130);
System.out.println((byte)131);
}
}
/*
十进制：300
A:把十进制转换为二进制
00000000 00000000 00000001 00101100
B:截取
0 0101100
*/
算数运算符
/*
运算：对常量和变量进行操作的过程称为运算。
运算符：对常量和变量进行操作的符号称为运算符
表达式：由运算符把常量和变量连接起来的式子
a + b
注意：表达式必须有结果
常见的运算符：
算术运算符
赋值运算符
比较运算符
逻辑运算符
位运算符
三目运算符
算术运算符：
+，-，*，/，%，++，--
*/
class OperatorDemo {
public static void main(String[] args) {
System.out.println(10+20);
System.out.println(10-20);
System.out.println(10*20);
//整数相除，只能得到整数
System.out.println(10/20);
//要想得到小数，可以乘以或者除以1.0
System.out.println(10/1.0/20);
//加法的用法:正号,加法,字符串连接符
System.out.println(+5);
System.out.println(1+2);
System.out.println("1"+"2");
}
}
赋值运算符
/*
赋值运算符：
基本：=
复合：+=,-=,*=,/=,%=,...
*/
class OperatorDemo {
public static void main(String[] args) {
//把10赋值给int类型的变量a
int a = 10;
//复合的用法
int b = 10;
b += 20; //结果等价于：b = b + 20;
System.out.println(b);
}
}
关系运算符
/*
关系运算符：
==,!=,>,>=,<,<=
特点：
无论表达式是简单还是复杂，结果肯定是boolean类型。
注意事项：
关系运算符“==”不能误写成“=” 。
*/
class OperatorDemo {
public static void main(String[] args) {
int a = 10;
int b = 10;
int c = 20;
System.out.println(a == b);
System.out.println(a == c);
System.out.println((a + b*c) == (a*b + c));
System.out.println("----------------");
System.out.println(a = b); //把b的值赋值给a，把a的值作为结果留下来
System.out.println(a = c);
}
}
逻辑运算符
/*
逻辑运算符：
&,|,!,^
&&,||
注意：
逻辑运算符连接的应该是一个布尔表达式。
*/
class OperatorDemo {
public static void main(String[] args) {
//&,|,!,^
int a = 10;
int b = 20;
int c = 30;
//&:逻辑与 有false则false
System.out.println(a>b & a>c); //false & false = false
System.out.println(a>b & a<c); //false & true = false
System.out.println(a<b & a>c); //true & false = false
System.out.println(a<b & a<c); //true & true = true
System.out.println("--------");
//|:逻辑或 有true则true
System.out.println(a>b | a>c); //false | false = false
System.out.println(a>b | a<c); //false | true = true
System.out.println(a<b | a>c); //true | false = true
System.out.println(a<b | a<c); //true | true = true
System.out.println("--------");
//^:逻辑异或 相同false，不同true。
//情侣：男男，男女，女男，女女
System.out.println(a>b ^ a>c); //false ^ false = false
System.out.println(a>b ^ a<c); //false ^ true = true
System.out.println(a<b ^ a>c); //true ^ false = true
System.out.println(a<b ^ a<c); //true ^ true = false
System.out.println("--------");
//!:逻辑非
System.out.println((a>b));//false
System.out.println(!(a>b));//true
System.out.println(!!(a>b));//false
System.out.println(!!!(a>b));//true
System.out.println(!!!!(a>b));//false
}
}
位运算符
/*
位运算符：位运算符一定是先把数据转成二进制，然后再运算。
面试题：&和&&的区别?
A:&和&&都可以作为逻辑运算，&&具有短路效果。
B:&还可以作为位运算。
*/
class OperatorDemo {
public static void main(String[] args) {
//&,|,^,~
System.out.println(3 & 4); //0
System.out.println(3 | 4); //7
System.out.println(3 ^ 4); //7
System.out.println(~3); //
}
}
/*
A:计算出3，4的二进制
3的二进制：00000000 00000000 00000000 00000011
4的二进制：00000000 00000000 00000000 00000100
B:位&运算 有0则0
00000000 00000000 00000000 00000011
&00000000 00000000 00000000 00000100
------------------------------------
00000000 00000000 00000000 00000000
C:位|运算 有1则1
00000000 00000000 00000000 00000011
&00000000 00000000 00000000 00000100
------------------------------------
00000000 00000000 00000000 00000111
D:位^运算 相同则0，不同则1
00000000 00000000 00000000 00000011
&00000000 00000000 00000000 00000100
------------------------------------
00000000 00000000 00000000 00000111
E:位~运算 把数据每个位都按位取反
00000000 00000000 00000000 00000011
~11111111 11111111 11111111 11111100
反:11111111 11111111 11111111 11111011
原:10000000 00000000 00000000 00000100
*/
三元运算符
/*
三元运算符：
格式
(关系表达式)?表达式1：表达式2；
执行流程：
计算关系表达式，看其返回值
true:表达式1就是整个表达式的值
false:表达式2就是整个表达式的值
*/
class OperatorDemo {
public static void main(String[] args) {
//获取两个数据中的较大值
int x = 3;
int y = 4;
int z = (x > y)? x : y;
System.out.println(z);
//比较两个数是否相等
int a = 4;
int b = 4;
//boolean flag = (a==b)?true:false;
boolean flag = (a == b);
System.out.println(flag);
//获取三个数据中的较大值
int c = 30;
int d = 40;
int e = 50;
//int max = (c>d)?(c>e?c:e):(d>e?d:e);
int temp = (c>d)?c:d;
int max = (temp>e)?temp:e;
System.out.println(max);
}
}
键盘录入数据
/*
为了程序的数据更加的灵活，我们决定加入键盘录入数据。
如何使用键盘录入数据呢?目前你就给我记住了。
A:导包
import java.util.Scanner;
在class的上面
B:创建对象
Scanner sc = new Scanner(System.in);
C:获取数据
int i = sc.nextInt();
*/
import java.util.Scanner;
class OperatorDemo {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数：");
//获取数据
int i = sc.nextInt();
System.out.println("i:"+i);
}
}
顺序结构语句
/*
是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，
依次执行，程序中大多数的代码都是这样执行的。
总的来说：写在前面的先执行，写在后面的后执行
*/
class OrderDemo {
public static void main(String[] args) {
System.out.println("我爱林青霞");
System.out.println("我爱Java");
System.out.println("我爱张曼玉");
System.out.println("林青霞爱张曼玉");
}
}
选择结构（if语句）
/*
选择结构：if语句，switch语句。
if语句有三种格式。
if语句格式1：
if(关系表达式) {
语句体;
}
执行流程：
A:计算关系表达式，看其结果
B:如果是true，就执行语句体
如果是false，就不执行语句体
C:继续向下执行
*/
class IfDemo {
public static void main(String[] args) {
int x = 3;
if(x == 3) {
System.out.println("x等于3");
//x = 10;
}
if(x > 5) {
System.out.println("x大于5");
}
System.out.println("over");
}
}
选择结构（switch语句）
/*
switch语句格式：
switch(表达式) {
case 值1：
语句体1;
break;
case 值2：
语句体2;
break;
…
default：
语句体n+1;
break;
}
格式解释：
A:switch表示这是switch语句
B:表达式的取值
byte,short,int,char
JDK5以后可以是枚举类型。(enum)
JDK7以后可以是字符串。(String)
C:case后面跟的是要和表达式进行比较的值
D:语句体可以是多条语句
E:break表示中断，结束的意思，可以结束switch语句
F:default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。
面试题：
switch的表达式可以是byte类型吗?可以是long类型吗?可以是String类型吗?
可以。
不可以。
JDK7以后可以。
执行流程：
A:首先计算出表达式的值
B:其次，和case依次比较，一旦有对应的值，就会执行相应的语句，
在执行的过程中，遇到break就会结束。
C:最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
需求：根据键盘录入的数值1，2，3，…7输出对应的星期一，星期二，星期三…星期日。
分析：
A:键盘录入数据，用Scanner实现
B:对录入的数据进行判断，用switch实现
C:输出对应的结果
*/
import java.util.Scanner;
class SwitchDemo {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
//键盘录入数据
System.out.println("请输入一个数据(1-7)：");
int week = sc.nextInt();
//用switch语句实现
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;
}
}
}
循环语句（for）
/*
for循环的格式：
for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}
执行流程：
A:首先执行初始化语句
B:其次执行判断条件语句，看其返回值
如果是true，就继续
如果是false，循环结束
C:执行循环体语句
D:执行控制条件语句
E:回到B
*/
class ForDemo2 {
public static void main(String[] args) {
//在控制台输出10次HelloWorld
for(int x=0; x<10; x++) {
System.out.println("HelloWorld");
}
System.out.println("--------------");
//初始化不从0开始
for(int x=1; x<=10; x++) {
System.out.println("HelloWorld");
}
for(int x=1; x<11; x++) {
System.out.println("HelloWorld");
}
for(int x=10; x>0; x--) {
System.out.println("HelloWorld");
}
}
}
循环语句（while）
/*
while循环的格式：
while(条件表达式) {
语句体;
}
变形格式：
初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}
for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}
由此可见while循环和for循环是可以等价转换的。
*/
class WhileDemo {
public static void main(String[] args) {
//for
/*
for(int x=0; x<10; x++) {
System.out.println("HelloWorld");
}
System.out.println("--------------");
*/
//while
/*
int x=0;
while(x<10) {
System.out.println("HelloWorld");
x++;
}
*/
//求和
//for
/*
int sum = 0;
for(int x=1; x<=100; x++) {
sum+=x;
}
System.out.println("1-100之和是："+sum);
*/
//while
/*
int sum = 0;
int x = 1;
while(x<=100) {
sum += x;
x++;
}
System.out.println("1-100之和是："+sum);
*/
//水仙花
//for
/*
for(int x=100; x<1000; x++) {
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
if(x == (ge*ge*ge + shi*shi*shi + bai*bai*bai)) {
System.out.println(x);
}
}
*/
//while
int x = 100;
while(x<1000) {
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
if(x == (ge*ge*ge + shi*shi*shi + bai*bai*bai)) {
System.out.println(x);
}
x++;
}
}
}
循环语句（do…while）
/*
do...while格式：
do {
语句体;
}while(条件表达式);
变形格式：
初始化语句;
do {
循环体语句;
控制条件语句;
}while(判断条件语句);
for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}
*/
class DoWhileDemo {
public static void main(String[] args) {
/*
int sum = 0;
for(int x=1; x<=100; x++) {
sum+=x;
}
System.out.println(sum);
*/
//do...while
int sum = 0;
int x = 1;
do{
sum+=x;
x++;
}while (x<=100);
System.out.println(sum);
}
}
循环语句（嵌套使用）
/*
需求：请输出如下图形
*
**
***
****
*****
*/
class ForForDemo2 {
public static void main(String[] args) {
//我们先输出一个5行5列的星形
/*
for(int x=0; x<5; x++) {
for(int y=0; y<5; y++) {
System.out.print("*");
}
System.out.println();
}
*/
//而我们现在需要的是下半部分
//通过观察图形：我们知道行没有变化，是列在变化
//第一行：1列
//第二行：2列
//第三行：3列
//第四行：4列
//第五行：5列
//既然是一个变化的数，那么我们就定义一个变量
/*
int z = 0;
for(int x=0; x<5; x++) {
for(int y=0; y<=z; y++) {
System.out.print("*");
}
System.out.println();
z++;
}
*/
//我们发现z的变化和x的变化其实是一致的
//所以我们根本就没有必要定义z变量，直接把z用x替换
for(int x=0; x<5; x++) {
for(int y=0; y<=x; y++) {
System.out.print("*");
}
System.out.println();
}
System.out.println("---------");
for(int x=1; x<=5; x++) {
for(int y=1; y<=x; y++) {
System.out.print("*");
}
System.out.println();
}
}
}
控制跳转语句
/*
根据要求填空
*/
class BreakAndContinue {
public static void main(String[] args) {
for(int x=1; x<=10; x++) {
if(x%3==0) {
//在此处填写代码
break;
//continue;
//System.out.println("Java基础班");
}
System.out.println("Java基础班");
}
//我想在控制台输出2次:“Java基础班“
//我想在控制台输出7次:“Java基础班“
//我想在控制台输出13次:“Java基础班“
}
}
/*
break:中断
break的使用场景：
A:在选择结构switch语句中
B:在循环语句中
离开使用场景的存在是没有意义的
break:
A:跳出单层循环
B:跳出多层循环(了解)
带标签的用法
*/
class BreakDemo {
public static void main(String[] args) {
for(int x=0; x<10; x++) {
//System.out.println(x);
if(x%2==0) {
break;
//break后面是不能有东西的
//System.out.println(x);
}
System.out.println(x);
}
System.out.println("-------------");
wc:for(int x=0; x<3; x++) {
nc:for(int y=0; y<4; y++) {
System.out.print("*");
break;
}
System.out.println();
}
}
}
/*
continue的使用场景：
在循环语句中
离开使用场景的存在是没有意义的
continue的作用：
A:单层循环对比break，然后总结两个的区别
break 退出当前循环
continue 退出本次循环
B:也可以带标签的使用
*/
class ContinueDemo {
public static void main(String[] args) {
//continue;
for(int x=0; x<10; x++) {
if(x%2==0) {
//break; //结束当前循环
continue; //结束本次循环操作，进入下一次操作
}
System.out.println(x);
}
wc:for(int x=0; x<3; x++) {
nc:for(int y=0; y<4; y++) {
System.out.print("*");
continue wc;
}
System.out.println();
}
}
}
/*
return：结束方法的。
*/
class ReturnDemo {
public static void main(String[] args) {
for(int x=0; x<10; x++) {
if(x%3==0) {
//break;
//continue;
return;
}
System.out.println(x);
}
System.out.println("over");
}
}
方法
/*
方法：完成特定功能的代码块
格式：
修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {
方法体;
return 返回值;
}
修饰符：public static
返回值类型：功能最终的值的数据类型
方法名：是为了方便调用而起的一个名字
参数：
形式参数：用于接受实际参数的变量
实际参数：实际参与运算的数据
方法体：完成特定功能的代码
return 返回值：通过return把结果返回给调用者
我们虽然知道了方法的格式，那么我们该如何写一个方法呢?
两个明确：
A:返回值类型
结果的数据类型
B:参数列表
有几个参数参加，并且每个参数的数据类型是什么
需求：求两个数据之和的案例
A:我没有说数据的类型，默认int类型。
B:求两个数据的和
说明有两个参数参加，并且默认都是int类型
C:两个int类型相加的结果是什么类型呢?
是int类型，所以返回值类型这里是int类型
方法的执行特点：
不调用不执行。
有明确返回值的方法的调用：
A:单独调用，没有意义。
B:输出调用，不是很好，因为我们可能需要针对结果还要进行其他的操作。
C:赋值调用，推荐方式。
*/
class MethodDemo {
public static void main(String[] args) {
//定义两个变量
int x = 10;
int y = 20;
//单独调用
//sum(x,y);
//输出调用
System.out.println(sum(x,y));
//赋值调用
int result = sum(x,y);
//result进行操作
System.out.println(result);
}
//如果我自己要想写一个方法
public static int sum(int a,int b) {
int c = a + b;
return c;
}
}
方法重载
/*
方法重载：
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
和返回值类型无关。
*/
class MethodDemo {
public static void main(String[] args) {
//需求：请写一个功能，实现两个数据的求和
System.out.println(sum(10,20));
//需求：请写一个功能，实现三个数据的求和
//System.out.println(sum2(10,20,30));
System.out.println(sum(10,20,30));
System.out.println(sum(1.5,2.5));
}
public static int sum(int a,int b) {
return a + b;
}
/*
public static int sum2(int a,int b,int c) {
return a + b + c;
//方法的嵌套调用
//return sum(sum(a,b),c);
}
*/
//由于方法名要表达的其实是该方法的作用
//所以，sum2这个名字不好，还是要用sum 比较好
public static int sum(int a,int b,int c) {
return a + b + c;
}
public static double sum(double a,double b) {
return a + b;
}
}
一维数组
/*
数组：存储同一种数据类型的多个元素的集合。(也可以称为容器)
数组的定义格式：
格式1：数据类型[] 数组名;
int[] arr;
格式2：数据类型 数组名[];
int arr[];
推荐方式1。
现在的数组没有元素，使用是没有意义的。
接下来，我们要对数组进行初始化。
那么，我们如何对数组进行初始化呢?
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
动态初始化：
数据类型[] 数组名 = new 数据类型[数组长度];
*/
class ArrayDemo {
public static void main(String[] args) {
//按照动态初始化数组的格式，我们来定义一个存储3个int类型元素的数组
int[] arr = new int[3];
/*
左边：
int:说明数组中的元素的数据类型。
[]:说明这是一个数组
arr:数组的名称
右边：
new:为实体(对象)开辟内存空间
Scanner sc = new Scanner(System.in);
int:说明数组中的元素的数据类型。
[]:说明这是一个数组
3:说明的是数组中的元素个数
*/
//我们如何获取里面的值呢?
//数组名称
System.out.println(arr); //[I@778b3fee 地址值
//如何获取元素值呢?
//数组为每个元素分配了一个编号，这个编号的专业叫法：索引。
//而且是从0开始编号的。也就是说数组的最大编号是长度-1。
//有了编号以后，我们就可以通过数组名和编号的配合取得数组元素
//格式：数组名[编号];
System.out.println(arr[0]); //0
System.out.println(arr[1]); //0
System.out.println(arr[2]); //0
}
}
二位数组
/*
二维数组：元素为一维数组的数组。
定义格式1：
数据类型[][] 变量名 = new 数据类型[m][n];
m:m表示这个二维数组有多少个一维数组
n:n表示每一个一维数组的元素个数
变形：
数据类型 变量名[][] = new 数据类型[m][n];
数据类型[] 变量名[] = new 数据类型[m][n];
int[] x,y[];
*/
class Array2Demo {
public static void main(String[] args) {
//定义一个二维数组
int[][] arr = new int[3][2];
//表示arr这个二维数组有三个元素
//每个元素是一个一维数组
//每一个一维数组有2个元素
System.out.println(arr); //[[I@778b3fee
System.out.println(arr[0]); //[I@57125f92
System.out.println(arr[1]);
System.out.println(arr[2]);
//如何输出元素呢?
System.out.println(arr[0][1]);
System.out.println(arr[2][2]);
}
}
To be continued
将编程看作是一门艺术，而不单单是个技术。
敲打的英文字符是我的黑白琴键，
思维图纸画出的是我编写的五线谱。
当美妙的华章响起，现实通往二进制的大门即将被打开。
GitHub2021年度前100的Java高频知识点汇总
