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
将编程看作是一门艺术，而不单单是个技术。 敲打的英文字符是我的黑白琴键， 思维图纸画出的是我编写的五线谱。 当美妙的华章响起，现实通往二进制的大门即将被打开。