概述
Java_关键字&常量&变量&运算符&顺序结构语句
Java语言基础(关键字的概述和使用)
A:什么是关键字
就是被java语言赋予特殊含义的单词。
B:关键字的特点
组成关键的字母都是小写
C:常见关键字
Java关键字:
int public this finally boolean abstract continue float long
short throw throws return break for static new interface if
default byte do case strictfp package super void try switch else catch implements private final class extends volatile
while synchronized instanceof char protect importd transient dafaule
double goto const
修饰符关键字:
public private protected
D:关键字的注意事项
(1): goto和const是java语言的保留字
(2): 类似与editplus这样的高级文本编辑器对关键字都是有颜色变化的
E：练习：判断下面那些是关键字
class ,HelloWorld,public,static,void,main,String,System
###01.23_Java语言基础(标识符的概述和组成规则)---"见名知意"
A:什么是标识符
就是给类,接口,方法,变量等起名字时使用的字符序列
B:标识符的组成规则
(1): 英文的大小写字母 52个字母a-z&A-Z
(2): 数字字符 0-9
(3): $和_
C:标识符注意事项
(1): 不能以数字开头
(2): 不能是java中的关键字
(3): 严格区分大小写
演示一下我们的注意事项;
练习：下面那些是合法的标识符
HelloWorld,DataClass,_983,$bS5_c7,class,DataClass#,98.3,Hell World
01.24_Java语言基础(标识符中常见的命名规则)(了解)
A:包(就是文件夹，它的存在是为了解决我们同一个目录下不能同时存在两个相同名称的文件。) package
字母都是小写
单级包： itcast
多级包： cn.itcast
B:类或者接口
一个单词：首字母大写，其余字母小写 Student，Teacher , Spring , Struts ， Hibernate
多个单词：每一个单词的首字母都是大写，其余字母小写StudentName ， UserLoginController.
C:方法或者变量
一个单词： 字母全是小写 name ， age , main 主方法:特殊单词使用.
多个单词： 从第二个单词开始，首字母大写，其余字母小写 getName ， getAge
D:常量
一个单词：字母全是大写 NAME , AGE
多个单词： 字母全是大写，每一个单词之间使用 _ 隔开 STUDENT_MAX_AGE
常量
常量的概述和使用
进制概述和二,八,十六进制图解
不同进制数据的表现形式
进制转化
有符号数据表示法
变量
变量的概述及格式
数据类型的概述和分类
数据类型转换之隐式转换
数据类型转换之强制转换
运算符
算术运算符
赋值运算符
关系运算符
02.01_Java语言基础(常量的概述和使用)(掌握)
A:什么是常量
就是在程序的执行过程中其值不发生改变的量。
B:Java中常量的分类
(1):字面值常量
(2):自定义常量(面向对象部分讲解)
C:字面值常量的分类
(1): 字符串常量 用双引号括起来的内容 "HelloWorld" ,"Hello" “ ”
(2): 整数常量 所有整数 12,23 byte&short&int(默认)&long
(3): 小数常量 所有小数 12.34,56.78 float&double(默认)
(4): 字符常量 用单引号括起来的内容 'a','A','0' (注意事项：单引号中只能是单个字母，单个数字，单个符号)
(5): 布尔常量 较为特有，只有true和false
(6): 空常量null(数组部分讲解,二维数组)
D:案例演示
用输出语句输出各种常量。
E:Java针对整数常量提供了4种表现形式
(1):二进制
(2):八进制
(3):十进制
(4):十六进制
02.02_Java语言基础(进制概述和二,八,十六进制图解)
A:什么是进制
就是进位制，是人们规定的一种进位方法。 对于任何一种进制--X进制，就表示某一位置上的数运算时是逢X进一位。
二进制就是逢二进一，八进制是逢八进一，十进制是逢十进一，十六进制是逢十六进一。
B:二进制的由来(电位码)
C:八进制的由来(三位)
D:十六进制的由来(四位)
E:不同进制表现同一个数据的形式特点
进制越大，表现形式越短
02.03_Java语言基础(不同进制数据的表现形式)
A:二进制的数据表现形式
由0,1组成。 以0b开头(1.7版本开始的，b可大写)
B:八进制的数据表现形式
由0,1,…7组成。 以0开头
C:十进制的数据表现形式
由0,1,…9组成。 整数默认是十进制的
D:十六进制的数据表现形式
由0,1,…9,a,b,c,d,e,f(大小写均可)。 以0x开头(x可大写)
E:案例演示()
输出不同进制表现10的数据。
0b10
010
10
0x10
代码演示:
class Demo{
public static void main(String[] args){
// 打印二进制的值
System.out.println(0b001001);
//打印八进制的值
System.out.println(01001);
//打印10进制的值
System.out.println(1001);
//打印16进制的值
System.out.println(0x001001);
}
}
02.04_Java语言基础(任意进制到十进制的转换图解)
A:任意进制到十进制的转换原理(12345)
位权展开法
十进制:
12345=1*10000+2*1000+3*100+4*10+5*1
=1*10^4+2*10^3+3*10^2+4*10^1+5*10^0
B:画图练习
二进制--十进制
八进制--十进制
十六进制--十进制
02.05_Java语言基础(十进制到任意进制的转换图解)
A:十进制到任意进制的转换原理(12345)
除基取余 直到商为0 余数反转
十进制到X进制这个基就是X。
B:画图练习(将十进制数的52分别转化成二进制，八进制，十六进制)
十进制--二进制
十进制--八进制
十进制--十六进制
02.06_Java语言基础(快速的进制转换法)
A:8421码及特点
8421码是中国大陆的叫法，8421码是BCD代码中最常用的一种。
在这种编码方式中每一位二值代码的1都是代表一个固定数值，把每一位的1代表的十进制数加起来，得到的结果就是它所代表的十进制数码。
B:通过8421码的方式进行二进制和十进制的相互转换
(1): 二进制到十进制的转化 (0b101101)
(2): 十进制到二进制的转化 (100)
C:二进制到八进制的简易方式 (100110) (3位为一组)
D:二进制到十六进制的简易方式(100110) (4位为一组)
###02.07_Java语言基础(原码反码补码的讲解)(了解)
A:为什么要讲解有符号数据表示法
其实我们可以不讲解这部分内容，因为我们在做运算的时候，我们使用的都是十进制数据做运算，
那么为了让同学们更好了理解计算机底层是如何做运算的，所以我们就增加了该部分的讲解。
B:有符号数据表示法的几种方式
原码 ， 反码(按位取反, 1变0,0变1) ， 补码(反码+1)
所有数据的运算都是采用补码进行的。
演示使用原码，反码，补码分别表示一下我们的 +7 和 -7
正数的原码 反码 和补码都是原码.
C:原码
就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。
D:反码
正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。
E:补码
正数的补码与其原码相同；负数的补码是在其反码的末位加1。
(应用:密码学)
02.08_Java语言基础(原码反码补码的练习)
A:已知原码求补码
已知某数X的原码为0B10110100，试求X的补码和反码。
B:已知补码求原码
已知某数X的补码0B11101110，试求其原码。
02.09_Java语言基础(变量的概述及格式)
A:什么是变量
在程序执行的过程中，在某个范围内其值可以发生改变的量.
理解：就相当与数学中的未知数
变量其实是内存中的一小块区域
B:为什么要定义变量
用来不断的存放同一类型的常量，并可以重复使用
C:变量的定义格式
数据类型 变量名 = 变量值 ；
02.10_Java语言基础(数据类型的概述和分类)
A:为什么有数据类型
我们都知道，变量其实就是内存中的一小块区域。我们定义一个变量，其实就是开辟了一个内存空间。如果没有数据类型，那么我们需要开辟多大的内存空间合适呢？为了解决这种问题，java就给我们提供了不同的数据类型，那么针对不同的数据类型，在内存中分配了不同大小的内存空间。
B:Java中数据类型的分类
(1): 基本数据类型
(2): 引用数据类型(后面讲解)： 数组 (array)， 类(class) ， 接口(interface)
C:基本数据类型的详细讲解
(1): 数值型
整数型 字节数 范围
byte 1(8bit) -128 ~ 127
short 2(16bit) -2^15 ~ 2^15 - 1
int 4(32bit) -2^31 ~ 2^31 - 1
long 8(64bit) -2^63 ~ 2^63 - 1
浮点数
float 4(32bit) -3.403*10^38 ~ 3.403*10^38
double 8(64bit) -1.798*10^308 ~ 1.798*10^308
(2): 字符型 char 2(16bit) 0 ~ 2^16 - 1 = 65535
(3): 布尔型 boolean 1
整数默认是int类型的 ， 浮点数默认是 double类型的
02.11_Java语言基础(定义不同数据类型的变量)
A:案例演示
定义不同基本数据类型的变量，并输出
02.12_Java语言基础(使用变量的注意事项)
A:案例演示
a:作用域问题
变量定义在哪一级大括号中，哪个大括号的范围就是这个变量的作用域。相同的作用域中不能定义两个同名变量。
b:初始化值问题
没有初始化值不能直接使用
c:在一行上建议只定义一个变量
可以定义多个，但是不建议
02.13_Java语言基础(数据类型转换之隐式转换)(掌握)
A:+是一个运算符, 我们应该能够看懂，做数据的加法
B:案例演示
a:int + int
b:byte + int 的结果分别用byte和int类型接收，看效果
C:Java中的默认转换规则
(1): boolean类型不能转换为其他的数据类型
(2): byte,short,char—int—long—float—double
(3): byte,short,char相互之间不转换，他们参与运算首先转换为int类型
D:画图解释byte+int类型的问题
02.14_Java语言基础(数据类型转换之强制转换)
A:强制转换问题的引入
B:强制转换的格式
目标数据类型 变量名=(目标数据类型)(被转换的数据);
C:强制转换的注意事项
尽量不要使用强制类型转化，因为可能存在损失精度的问题。
D:案例演示
byte + int 的结果赋值给byte，加强制类型转换
E： byte b = 130;有没有问题?如果我想让赋值正确，可以怎么做?结果是多少呢?
02.15_Java语言基础(面试题之变量相加和常量相加的区别)
A:案例演示
面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。
byte b1 = 3;
byte b2 = 4;
byte b3 = b1 + b2;
byte b4 = 3 + 4;
B:Java语言中的字符char可以存储一个中文汉字吗?为什么呢?
可以。因为Java语言采用的是Unicode编码。Unicode编码中的每个字符占用两个字节。
所以，Java中的字符可以存储一个中文汉字
02.16_Java语言基础(字符和字符串参与运算)(掌握)
A:案例演示
System.out.println('a');
System.out.println('a' + 1);
通过看结果知道'a'的值是多少,由此引出ASCII码表
B:ASCII码表的概述
记住三个值：
'0' 48
'A' 65
'a' 97
C:案例演示
System.out.println("hello" + 'a' + 1); helloa1
System.out.println('a' + 1 + "hello"); 98hello
System.out.println('a' + 1 + "hello"+(3+’A’+”hello”)); 98hello68hello
D:+在有字符串参与中被称为字符串连接符
找学生提问：
System.out.println("5+5="+5+5);
System.out.println(5+5+"=5+5");
02.17_Java语言基础(算术运算符的基本用法)
A:什么是运算符
对常量和变量进行操作的符号称为运算符
B:运算符的分类
算术运算符
赋值运算符
比较运算符
逻辑运算符
位运算符
三目运算符
C:算数运算符有哪些
+ , - ,+ , - , * , / , % , ++ , --
D:案例演示
算数运算符的基本用法
注意事项：
a:整数相除只能得到整数。如果想得到小数，请使用浮点数
b:/获取的是除法操作的商，%获取的是除法操作的余数
%运算结果的符号，取决于参与运算是左边的符号
02.18_Java语言基础(算术运算符++和--的用法)
A:++,--运算符的作用
自加（++）自减（--）运算
++:自加。对原有的数据进行+1
--:自减。对原有的数据进行-1
B:案例演示
a:单独使用：
放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)
b:参与运算使用：
放在操作数的前面，先自增或者自减，然后再参与运算。
放在操作数的后面，先参与运算，再自增或者自减。
02.19_Java语言基础(算术运算符++和--的练习)
A:案例演示
请分别计算出a,b,c的值?
int a = 10;
int b = 10;
int c = 10;
a = b++; //a=10 , b=11
c = --a; //c=9, a=9
b = ++a; //b=10, a=10
a = c--; //a=9, c=8
a=9 , b=10 , c=8
B:案例演示
请分别计算出x,y的值?
int x = 4;
4 + 6 6*10
int y = (x++)+(++x)+(x*10);
5 6
x=6
y=70
2.20_Java语言基础(赋值运算符的基本用法)
A:赋值运算符有哪些
=， +=, -=, *=,/=,%=
B:案例演示
赋值运算符的基本用法
注意事项：
a:基本的赋值运算符：=
把=右边的数据赋值给左边。
b:扩展的赋值运算符：+=,-=,*=,/=,%=
+= 把左边和右边做加法，然后赋值给左边。
c: 赋值运算符要求左边的数据必须是一个变量
02.21_Java语言基础(赋值运算符的面试题)
A:案例演示
面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。
short s=1;s = s+1; 有问题
short s=1;s+=1; 没有问题
02.22_Java语言基础(关系运算符的基本用法及其注意事项)
A:关系运算符有哪些
== ,!= , < , > , <= , >= , instanceof
注意事项：
无论你的操作是简单还是复杂，结果是boolean类型。
"=="不能写成"="。
B:案例演示
关系运算符的基本用法
02_23day02总结
03 运算符
逻辑运算符
位运算符
三元运算符
键盘录入数据
流程控制语句
顺序结构语句
选择结构
03.01_Java语言基础(逻辑运算符的基本用法)
A:逻辑运算符有哪些
&(并且) , |(或者) , !(非) , ^(异或) , &&(短路与) , ||(短路或)
注意事项：
a:逻辑运算符一般用于连接(boolean)布尔类型的表达式或者值。
在Java中我们要表示一个数大于3并且小于6 ，不可以写成3<x<6，应该写成 x>3 & x<6 。
b:表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
算术表达式：a + b
关系表达式：a == b
B:案例演示
逻辑运算符的基本用法
C:结论：
&逻辑与:有false则false。
| 逻辑或:有true则true。
^逻辑异或:相同为false，不同为true。
举例：情侣关系。男男,男女,女男,女女
!逻辑非:非false则true，非true则false。
特点：偶数个不改变本身。
03.02_Java语言基础(逻辑运算符&&和&的区别)
A:案例演示
&&和&的区别?
a:最终结果一样。
b:&&具有短路效果。左边是false，右边不执行。
B:同理||和|的区别?(学生自学)&&和&的区别?
||和|的区别?
a:最终结果一样。
b:|| 具有短路效果。左边是true，右边不执行。
C:开发中常用
(短路与)&&,(短路或)||,(非)!
作用: 提高运算效率
03.03_Java语言基础(位运算符的基本用法1)
A:位运算符有哪些
&(与)，|(或)，^(异或) , ~(按位取反) , <<(左移) ,>>(右移) ,>>>(无符号右移)
注意事项：位运算是直接对二进制补码进行运算。
B:案例演示
&,|,^,~ 的用法
&:有0则0
|:有1则1
^:相同则0，不同则1
~:按位取反
03.04_Java语言基础(位异或运算符的特点及面试题)
A:案例演示
位异或运算符的特点
^的特点：一个数据被另一个数据位异或两次，该数本身不变。
B:面试题：
请自己实现两个整数变量的交换
注意：以后讲课的过程中，我没有明确指定数据的类型，默认int类型。
03.05_Java语言基础(位运算符的基本用法2及面试题)
A:案例演示
>>,>>>,<<的用法:
<<:左移 空位补0，被移除的高位丢弃。
>>:右移 被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，高位补1。
>>>:无符号右移 被移位二进制最高位无论是0或者是1，空缺位都用0补。
B:结论：
<< : 把<<左边的数据乘以2的移动次幂
>> : 把>>左边的数据除以2的移动次幂
03.06_Java语言基础(三元运算符的基本用法)
A:三元(三目)运算符的格式
(关系表达式) ？ 表达式1 ： 表达式2；
B:三元运算符的执行流程
计算关系表达式的值，如果为true， 运算后的结果是表达式1；
如果为false，运算后的结果是表达式2；
C:案例演示
获取两个数中的最大值
/*====================================================================
class GetMax{ //定义类 class GetMax; class 类名(见名知意)
public static void main(String[] args){ // 主函数/方法main(){}
int a = 3; //定义常量int a ,b 的值;
int b = 5;
int max=(a>b)?a:b; //定义最大值max ,三目运算符(a>b)?a:b;
System.out.println(“max=”+max); //输出最大值;
}
}
====================================================================*/
03.07_Java语言基础(三元运算符的练习)(掌握)
A:案例演示
比较两个整数是否相同
/*====================================================================
class Equal{ //定义类 class Equal; class 类名(见名知意)
public static void main(String[] args){ // 主函数/方法main(){}
int a = 3; //定义常量int a ,b 的值;
int b = 5;
// 定义boolean z 判断表达式.相等输出true.不等输出flase;
boolean z = (a == b)?true:false;
System.out.println(z); //输出布尔判断z 的值.
}
}
=================================================================== */
B:案例演示
获取三个整数中的最大值
/*==================================================================
class GetMax{ //定义类 class Equal; class 类名(见名知意)
public static void main(String[] args){ // 主函数/方法main(){}
int a = 37; //定义常量int a ,b,c的值;
int b = 93;
int c =86;
int m =(a > b)?a:b; //三目运算符两两比较;
int max = (m > c)?m:c;
System.out.println(“max=”+max); //输出最大值.
}
}
====================================================================*/
03.08_Java语言基础(键盘录入的基本格式讲解)
A:为什么要使用键盘录入数据
a:为了让程序的数据更符合开发的数据(符合用户的数据输入)
b:让程序更灵活一下
B:如何实现键盘录入呢?
键盘录入步骤及格式:
a:导包
格式：
import java.util.Scanner;
位置：
在class上面。
b:创建键盘录入对象
格式：
Scanner sc = new Scanner(System.in);
c:通过对象获取数据
格式：
int x = sc.nextInt();
C:案例演示
键盘录入1个整数，并输出到控制台。
键盘录入2个整数，并输出到控制台。
/*====================================================================
import java.util.Scanner; //第一步:导入Scanner包;位置在class上面;
class JplrDemo{ //定义类
public static void main(String[] args){
//创建键盘录入对象;
Scanner sc = new Scanner(System.in);
System.out.println("请输入任意整数:");
//通过对象接收数据;
int x = sc.nextInt();
System.out.println(x);
/*键盘输入第二个对象
System.out.println("请输入任意整数:");
int y = sc.nextInt();
//输出对象;
System.out.println(y);
*/
}
}
====================================================================*//
###03.09_Java语言基础(键盘录入的练习1)
A:案例演示
键盘录入练习：键盘录入两个数据，并对这两个数据求和，输出其结果
/*===================================================================
import java.util.Scanner;
class GetSum{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个任意整数:");
int x = sc.nextInt();
System.out.println("请输入第二个任意整数:");
int y = sc.nextInt();
int sum =x+y;
System.out.println("和为 "+sum);
}
}
====================================================================*/
B:案例演示
键盘录入练习：键盘录入两个数据，获取这两个数据中的最大值
/*===================================================================
import java.util.Scanner;
class GetMax{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个任意整数:");
int x = sc.nextInt();
System.out.println("请输入第二个任意整数:");
int y = sc.nextInt();
int max =(x>y)?x:y;
System.out.println("最大值为 "+max);
}
}
====================================================================*/
03.10_Java语言基础(键盘录入的练习2)
A:案例演示
键盘录入练习：键盘录入两个数据，比较这两个数据是否相等
/*===================================================================
import java.util.Scanner;
class Equal
{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个任意整数:");
int a = sc.nextInt();
System.out.println("请输入第二个任意整数:");
int b = sc.nextInt();
boolean z = (a==b)? true:false;
System.out.println(z);
}
}
====================================================================*/
B:案例演示
键盘录入练习：键盘录入三个数据，获取这三个数据中的最值.
/*===================================================================
import java.util.Scanner; // 第一步:导入Scanner包;
class GetMax //定义类 class.求最大值
{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个任意数:");
int a = sc.nextInt();
System.out.println("请输入第二个任意数:");
int b = sc.nextInt();
System.out.println("请输入第三个任意数");
int c = sc.nextInt();
int x = (a>b)?a:b;
int max=(x>c)?x:c;
System.out.println("最大值为"+max);
//求最小值
//int x = (a>b)?b:a;
//int min=(x>c)?c:x;
// System.out.println("最小值为"+min);
}
}
====================================================================*/
03.11_Java语言基础(顺序结构语句)
A:什么是流程控制语句
在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。
也就是说程序的流程对运行结果有直接的影响。所以，我们必须清楚每条语句的执行流程。
而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能
B:流程控制语句的分类
顺序结构 (从上到下依次执行)
选择结构
(if语句-三目运算符/if else语句(双分支结构)&if (){}else if(){}...(多分支结构)
&switch语句)
循环结构 for (;;){}/for嵌套-for(;;){for (;;){}} & while(){} / do {}while(){}
B-1：顺序结构
是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
总的来说：写在前面的先执行，写在后面的后执行
执行流程：
从上往下，依次执行。
案例演示
输出几句话看效果即可.
03.12_Java语言基础(选择结构if语句格式1及其使用)(掌握)
概述：也被称为分支结构。
选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断，逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。
A:选择结构的分类
if语句
switch语句
B:if语句有几种格式
格式1
格式2
格式3
C:if语句的格式1:
if(比较表达式) {
语句体;
}
D:执行流程：
先计算比较表达式的值，看其返回值是true还是false。
如果是true，就执行语句体；
如果是false，就不执行语句体；
E:案例演示
判断两个数据是否相等.
03.13_Java语言基础(选择结构if语句注意事项)
A:案例演示
a:比较表达式无论简单还是复杂，结果必须是boolean类型
b:if语句控制的语句体如果是一条语句，大括号可以省略；如果是多条语句，就不能省略。建议永远不要省略。
c:一般来说：有左大括号就没有分号，有分号就没有左大括号
###03.14_Java语言基础(选择结构if语句格式2及其使用)
A:if语句的格式2
if(比较表达式) {
语句体1;
}else {
语句体2;
}
注意事项：else后面是没有比较表达式的，只有if后面有。
B:执行流程：
首先计算比较表达式的值，看其返回值是true还是false。
如果是true，就执行语句体1；
如果是false，就执行语句体2；
C:案例演示
a:获取两个数据中较大的值
b:判断一个数据是奇数还是偶数,并输出是奇数还是偶数
/*====================================================================
import java.util.Scanner;
class JudgeDemo
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
System.out.println("请输入任意整数:");
int x = sc.nextInt();
if(x%2==0){
System.out.println("您输入的整数是偶数");
}
else{
System.out.println("您输入的整数是奇数");
}
}
}
====================================================================*/
03.15_Java语言基础(if语句的格式2和三元的相互转换问题)
A：案例演示
获取两个数中较大的值。
判断一个数据是奇数还是偶数,并输出是奇数还是偶数
同时使用if语句和三元运算符进行操作。
三元运算符实现的，都可以采用if语句实现。反之不成立。
什么时候if语句实现不能用三元改进呢?
当if语句控制的操作是一个输出语句的时候就不能使用三元运算符。
为什么呢?
因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出。
03.16_Java语言基础(选择结构if语句格式3及其使用)
A:if语句的格式3：
if(比较表达式1) {
语句体1;
}else if(比较表达式2) {
语句体2;
}else if(比较表达式3) {
语句体3;
}
...
else {
语句体n+1;
}
B:执行流程：
首先计算比较表达式1看其返回值是true还是false，
如果是true，就执行语句体1，if语句结束。
如果是false，接着计算比较表达式2看其返回值是true还是false，
如果是true，就执行语句体2，if语句结束。
如果是false，接着计算比较表达式3看其返回值是true还是false，
...
如果都是false，就执行语句体n+1。
注意事项： 当只要有一个条件满足时，if语句结束。else是可以省略，但是不建议省略。
C:案例演示
//需求：键盘录入一个成绩，判断并输出成绩的等级。
/*
90-100 优秀
80-89 良
70-79 中
60-69 及格
0-59 差
*/
/*====================================================================
import java.util.Scanner;
class Demo
{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入您的成绩:");
int x = sc.nextInt();
if(x>100 || x<0 ){ //判定取值范围用(短路或)||语句,有true则true.
System.out.println("您输入的成绩不存在,请再次输入!!!");
}
else if (x>=90 && x<=100)
{
System.out.println("优秀");
}
else if(x>=80 && x<=89)
{
System.out.println("良");
}
else if(x>=70 && x<=79)
{
System.out.println("中");
}
else if(x>=60 && x<=69)
{
System.out.println("及格");
}
}
}
====================================================================*/
###03.17_Java语言基础(选择结构if语句练习题)
A:练习题
需求：
键盘录入x的值，计算出y的值并输出。
x>=3 y = 2x + 1;
-1<=x<3 y = 2x;
x<=-1 y = 2x – 1;
/*====================================================================
//键盘录入x的值,计算出y的值并输出.
import java.util.Scanner;
class Demo
{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
for(;;){ //使用死循环for(;;){}实现任意次输入;
System.out.println("请输入任意一个数");
int x = sc.nextInt();
int y1=2*x+1; //y=2x 输入应为: y = 2 * x ;
int y2=2*x;
int y3=2*x-1;
if(x>=3){
System.out.println("y1="+y1);
}else if(x>=1 && x<3){
System.out.println("y2="+y2);
}else if(x<=-1){
System.out.println("y3="+y3);
}
}
}
}
====================================================================*/
03.18_Java语言基础(选择结构if语句的嵌套使用)
A:案例演示
需求：获取三个数据中的最大值
if语句的嵌套使用。
可以三元实现，也可以if嵌套实现。
/*====================================================================
//if嵌套代码实现如下:
import java.util.Scanner;
class GetMaxDemo
{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
for(;;){
System.out.println("请输入第一个任意数:");
int a = sc.nextInt();
System.out.println("请输入第二个任意数:");
int b = sc.nextInt();
System.out.println("请输入第三个任意数:");
int c = sc.nextInt();
if(a>b){
if(a>c){
System.out.println("最大值是"+a);
}else{
System.out.println("最大值是"+c);
}
}else if(a<b){
if(b>c){
System.out.println("最大值是"+b);
}else{
System.out.println("最大值是"+c);
}
}
}
}
}
//三元运算符实现如下:--------------------------------------------------------------------------------------
import java.util.Scanner;
class GetMaxDemo
{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
for(;;){
System.out.println("请输入第一个任意数:");
int a = sc.nextInt();
System.out.println("请输入第二个任意数:");
int b = sc.nextInt();
System.out.println("请输入第三个任意数:");
int c = sc.nextInt();
int x = (a>b)?a:b;
int max =(x>c)?x:c;
System.out.println("最大值为"+max);
}
}
}
====================================================================*/
03.19_Java语言基础(选择结构switch语句的格式及其解释)
A:switch语句的格式
switch(表达式){
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
case 值3:
语句体3;
break;
....
default：
语句体n+1;
break;
}
B:switch语句的格式解释
(1):switch表示这是switch语句
表达式的取值：byte,short,int,char(字符)
JDK5以后可以是枚举(什么是枚举，以后再讲)
JDK7以后可以是String
(2):case后面跟的是要和表达式进行比较的值
(3):语句体部分可以是一条或多条语句
(4):break表示中断，结束的意思，可以结束switch语句
(5):default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似
C:面试题
byte可以作为switch的表达式吗?
long可以作为switch的表达式吗?
String可以作为switch的表达式吗?
C:执行流程
先计算表达式的值
然后和case后面的匹配，如果匹配成功就执行对应的语句，遇到break就会结束,否则执行default控制的语句
03.20_Java语言基础(选择结构switch语句的基本使用)
定义固定值
A:整数(给定一个值输出对应的星期一，星期二，星期三…星期日)
B:字符(单选题)
System.out.println("我们传智播客开设了那些专业？");
System.out.println("A 挖掘机专业");
System.out.println("B 美容美发专业");
System.out.println("C JAVA专业");
System.out.println("D 机械及自动化专业");
C:字符串(根据给定字符串输出对应值)
/*====================================================================
//给定一个值输出对应的星期一，星期二，星期三…星期日
class SwitchDemo
{
public static void main(String[] args){
int x=2;
switch(x = 2){
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;
default:
{System.out.println("星期日");}
break;
}
}
}
//键盘录入x的值,并打印出对应的星期天;
import java.util.Scanner;
class SwitchDemo
{
public static void main(String[] args){
while(true){
Scanner sc = new Scanner(System.in);
System.out.println("请输入任意整数:");
int x = sc.nextInt();
switch(x){
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;
}
}
}
}
====================================================================*/
03.21_Java语言基础(选择结构switch语句的注意事项)
A:案例演示
a:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
b:default可以省略吗?
可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
c:break可以省略吗?
可以省略，但是结果可能不是我们想要的。
会出现一个现象：case穿透。
最终我们建议不要省略
d:default一定要在最后吗?
不是，可以在任意位置。但是建议在最后。
e:switch语句的结束条件
a:遇到break就结束了
b:执行到末尾就结束了
03.22_Java语言基础(选择结构switch语句练习)
A:看程序写结果：
int x = 2;
int y = 3;
switch(x){
default:
y++;
break;
case 3:
y++;
case 4:
y++;
}
System.out.println("y="+y); //y=4;
B:看程序写结果：
int x = 2;
int y = 3;
switch(x){
default:
y++;
case 3:
y++;
case 4:
y++;
}
System.out.println("y="+y); //y=6; case穿透,执行完default;
###03.23_Java语言基础(选择结构if语句和switch语句的区别)
A:案例演示
分别用switch语句和if语句实现下列需求：
键盘录入月份，输出对应的季节
/*====================================================================
//先写思想,在写代码; 12.1.2 冬季 3.4.5春季 6.7.8.夏季 9.10.11 秋季 if语句实现;
import java.util.Scanner;
class Demo
{
public static void main(String[] args){
while(true){
Scanner sc = new Scanner(System.in);
System.out.println("请输入月份:");
int x = sc.nextInt();
if(x>12||x<1){
System.out.println("您输入的月份不存在!");
}else if(x>=3&&x<=5){
System.out.println("您输入的月份是在春季");
}else if(x>=6&&x<=8){
System.out.println("您输入的月份是在夏季");
}else if(x>=9&&x<=11){
System.out.println("您输入的月份是在秋季");
}else {
System.out.println("您输入的月份是在冬季");
}
}
}
}
----------------------------------------------------------------------------------------------------------------------
//先写思想,在写代码; 12.1.2 冬季 3.4.5春季 6.7.8.夏季 9.10.11 秋季 switch语句实现;
import java.util.Scanner;
class Demo
{
public static void main(String[] args){
while(true){
Scanner sc = new Scanner(System.in);
System.out.println("请输入月份:");
int x = sc.nextInt();
switch(x){
case 3:
case 4:
case 5:
System.out.println("您输入的月份属于春季");
break;
case 6:
case 7:
case 8:
System.out.println("您输入的月份属于夏季");
break;
case 9:
case 10:
case 11:
System.out.println("您输入的月份属于秋季");
break;
case 12:
case 1:
case 2:
System.out.println("您输入的月份属于冬季");
break;
default:
System.out.println("您输入的月份不存在!");
break;
}
}
}
}
====================================================================*/
B:在做判断的时候，我们有两种选择，if语句和switch语句，那么，我们到底该如何选择使用那种语句呢?
if语句使用场景：
针对结果是boolean类型的判断(true or false)
针对一个范围的判断(取值范围)
针对几个常量值的判断
switch语句使用场景：
针对几个常量值的判断
03.24_day03总结
=====================================================================
day04授课目录：
流程控制语句之循环语句
for循环
while循环
while语句
do...while语句
控制跳转语句
break
continue
return
方法(函数)
###04.01_Java语言基础(循环结构概述和for语句的格式及其使用)(掌握)
案例：在控制台输出10次"helloworld";
A:什么是循环结构
循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环.
B:循环结构的分类
for循环
while循环
C:循环结构for语句的格式：
for(初始化表达式语句;判断条件语句;控制条件语句) {
循环体语句;
}
D:执行流程：
a:执行初始化语句
b:执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环
c:执行循环体语句;
d:执行控制条件语句
e:回到B继续。
E: 注意事项:
初始化表达式语句只执行一次
B:注意事项
a:判断条件语句无论简单还是复杂结果是boolean类型。
b:循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。
c:一般来说：有左大括号就没有分号，有分号就没有左大括号
把刚才的需求使用for循环进行改进。
在控制台输出10次"helloworld";
/*====================================================================
//在控制台输出10次"helloworld";
class Demo
{
public static void main(String[] args){
for(int x =1;x>=1&& x<=10;x++){
System.out.println("Hello world");
}
}
}
====================================================================*/
04.02_Java语言基础(循环结构for语句的练习之获取数据)
A:案例演示
需求：请在控制台输出数据1-10
需求：请在控制台输出数据10-1
/*====================================================================
//需求：请在控制台输出数据1-10
class Demo{
public static void main(String[] args){
for(int x=1;x>=1&&x<=10;x++){
System.out.println(x);
}
}
}
-----------------------------------------------------------------------------------------------------------------
//需求：请在控制台输出数据10-1;
class Demo{
public static void main(String[] args){
for(int x=10;x>=1&&x<=10;x--){
System.out.println(x);
}
}
}
====================================================================*/
04.03_Java语言基础(循环结构for语句的练习之求和思想)(掌握)
A:案例演示
需求：求出1-10之间数据之和
B:学生练
需求：求1-100之和
需求：求出1-100之间偶数和
需求：求出1-100之间奇数和
/*====================================================================
//需求：求1-100之和
class Demo{
public static void main(String[] args){
int sum=0;
//for(初始化表达式语句;判断条件语句;控制条件语句) {循环体语句;}
for(int x =1;x<=100;x++){
sum += x;
}
System.out.println(sum);
}
}
//需求：求出1-100之间偶数和
class Demo
{
public static void main(String[] args){
int sum2=0;
for(int x =1;x<=100;x++){ //for循环遍历x的取值范围;
if(x%2==0){ //if判断偶数值
sum += x;
}
}
System.out.println(sum);
}
}
----------------------------------------------------------------------------------------------------------------------
//需求：求出1-100之间奇数和
class Demo
{
public static void main(String[] args){
int sum2=0;
for(int x =1;x<=100;x++){
if(x%2!=0){
sum2 += x;
}
}
System.out.println(sum2);
}
}
====================================================================*/
###04.04_Java语言基础(循环结构for语句的练习之水仙花)
A:案例演示
需求：在控制台输出所有的”水仙花数”
所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
举例：153就是一个水仙花数。
153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153
/*====================================================================
class Demo{
public static void main(String[] args){
for(int x =100;x<=999; x++){
int g =x%10;
int s =x/10%10;
int b =x/10/10%10;
int y= g*g*g+s*s*s+b*b*b;
if(x ==y ){
System.out.println(x);
}
}
}
}
====================================================================*/
###04.05_Java语言基础(循环结构for语句的练习之统计思想)
A:案例演示
需求：统计”水仙花数”共有多少个
/*====================================================================
class Demo
{
public static void main(String[] args){
int count=0;
for(int x =100;x<=999; x++){
int g =x%10;
int s =x/10%10;
int b =x/10/10%10;
int y= g*g*g+s*s*s+b*b*b;
if(x ==y ){
count++;
}
}
System.out.println("count="+count); //注意for循环的范围;
}
}
====================================================================*/
04.06_Java语言基础(循环结构while语句的格式和基本使用)
A:循环结构while语句的格式：
while循环的基本格式：
while(判断条件语句) {
循环体语句;
}
完整格式：
初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}
B:执行流程：
a:执行初始化语句
b:执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环
c:执行循环体语句;
d:执行控制条件语句
e:回到b继续。
C:案例演示
需求：在控制台输出10次"helloworld"
需求：请在控制台输出数据1-10
/*====================================================================
需求：在控制台输出10次"helloworld"
需求：请在控制台输出数据1-10
//在控制台输出10次"helloworld"
class Demo
{
public static void main(String[] args){
int x=0;
while(x<=10){
System.out.println("helloworld");
x++;
}
}
}
//需求：请在控制台输出数据1-10
class Demo
{
public static void main(String[] args){
int x=1; //初始化语句
while(x<=10){ //判断语句
System.out.println(x); //循环体;
x++; //控制语句
}
}
}
====================================================================*/
###04.07_Java语言基础(循环结构while语句的练习)
A:求和思想
求1-100之和
B:统计思想
统计”水仙花数”共有多少个
/*====================================================================
//求1-100之和;
class Demo
{
public static void main(String[] args){
int x=1;
int sum=0;
while(x<=100){
sum+=x;
x++;
}
System.out.println(sum);
}
}
--------------------------------------------------------------------------------------------------------------------
//需求:统计”水仙花数”共有多少个
class Demo
{
public static void main(String[] args){
int count=100;
int x=100;
while(x<=999){
int g = x%10;
int s = x/10%10;
int b = x/100%10;
int y = g*g*g+s*s*s+b*b*b;
if(x==y){
count++;
}
x++;
}
System.out.println("Count:"+count);
}
}
====================================================================*/
###04.08_Java语言基础(循环结构do...while语句的格式和基本使用)
A:循环结构do...while语句的格式：
do {
循环体语句;
}while(判断条件语句);
完整格式；
初始化语句;
do {
循环体语句;
控制条件语句;
}while(判断条件语句);
B:执行流程：
a:执行初始化语句;
b:执行循环体语句;
c:执行控制条件语句;
d:执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环
e:回到b继续。
C:案例演示
需求：在控制台输出10次"helloworld"
需求：请在控制台输出数据1-10
###04.09_Java语言基础(循环结构三种循环语句的区别)(掌握)
三种循环语句的区别:
(1):do...while循环至少执行一次循环体。
而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。
(2):A： 如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用for循环。
因为变量及早的从内存中消失，可以提高内存的使用效率。
B:建议优先考虑for循环，然后是while循环 ，最后是do...while循环
###04.10_Java语言基础(循环结构注意事项之死循环)(掌握)
A:一定要注意控制条件语句控制的那个变量的问题，不要弄丢了，否则就容易死循环。
B:两种最简单的死循环格式
while(true){...}
for(;;){...}
###04.11_Java语言基础(循环结构循环嵌套输出4行5列的星星)
A:案例演示
需求：请输出一个4行5列的星星(*)图案。
如图：
*****
*****
*****
*****
注意：
System.out.println("*");和System.out.print("*");的区别 换行
B:结论：
外循环控制行数，内循环控制列数
###04.12_Java语言基础(循环结构循环嵌套输出正三角形)
A:案例演示
需求：请输出下列的形状
*
**
***
****
*****
###04.13_Java语言基础(循环结构九九乘法表)
A:案例演示
需求：在控制台输出九九乘法表。
/*====================================================================
//九九乘法表
class Demo{
public static void main(String[] args){
int x;
int y;
for(x=1;x<=9;x++){
for(y=1;y<=x;y++){
System.out.print(y+"*"+x+"="+x*y+"t");
}
System.out.println(" "); //换行
}
}
}
====================================================================*/
B:代码优化
注意：
"x" x表示任意，这种做法叫转移字符。
"t" tab键的位置
"n" 换行
###04.14_Java语言基础(控制跳转语句break语句)(掌握)
A:什么是控制跳转语句
前面我们已经说过了，Java中的goto是保留字，目前不能使用。虽然没有goto语句可以增强程序的安全性，但是也带来很多不便，
比如说，我想在某个循环执行到某一步的时候就结束，现在就做不了这件事情。
为了弥补这个缺陷，Java就提供了break，continue和return来实现控制语句的跳转和中断。
B:控制跳转语句的分类
break 中断
continue 继续
return 返回
C:break的使用场景
(1):在选择结构switch语句中
(2):在循环语句中
注意：离开使用场景的存在是没有意义的
D:作用
a:退出单层循环
b:退出多层循环(几乎不使用)
要想实现这个效果，就必须知道一个东西;带标签的语句；
格式：标签名：语句
###04.15_Java语言基础(控制跳转语句continue语句)
A:continue的使用场景
(1):在循环语句中
(2):离开使用场景的存在是没有意义的
B:作用
a:跳出一次循环，执行下一步操作
C:练习题
for(int x=1; x<=10; x++) {
if(x%3==0) {
//在此处填写代码
}
System.out.println(“Java基础班”);
}
我想在控制台输出2次:“我想在控制台输出2次:“Java基础班“
Java基础班“
break;
我想在控制台输出7次:“Java基础班“
continue ;
我想在控制台输出13次:“Java基础班“
System.out.println(“Java基础班”);
=====================================================================
class BreakDemo{
public static void main(String[] args){
for(int x=1; x<=10; x++) {
if(x%3==0) {
break; // 输出2次;当x=3时中断;
continue; //输出7次;跳过3.6.9;
}
System.out.println("Java基础班!");
}
}
}
=====================================================================
04.16_Java语言基础(控制跳转语句return语句)
A:return的作用
return 就是退出一个方法。
跳转到上层调用的方法。这个在方法的使用那里会在详细的讲解。
B:案例演示
return: 结束当前方法
break:结束单层循环
continue: 结束当前循环，执行下一次循环
=================================================================
class ReturnDemo {
public static void main(String[] args) {
// 在控制台输出1-10
for(int x = 1 ; x <= 10 ; x++){
if(x == 3){
//break ;
//continue ;
//return ;
}
System.out.println(x);
}
System.out.println("over...........");
}
}
=====================================================================
04.17_Java语言基础(方法概述和格式说明)
A:为什么要有方法
假设有一个游戏程序，程序在运行过程中，要不断地发射炮弹(植物大战僵尸)。发射炮弹的动作需要编写100行的代码，在每次实现发射炮弹的地方都需要重复地编写这100行代码，这样程序会变得很臃肿，可读性也非常差。为了解决代码重复编写的问题，可以将发射炮弹的代码提取出来放在一个{}中，并为这段代码起个名字，这样在每次发射炮弹的地方通过这个名字来调用发射炮弹的代码就可以了。上述过程中，所提取出来的代码可以被看作是程序中定义的一个方法，程序在需要发射炮弹时调用该方法即可。
B:什么是方法
方法就是完成特定功能的代码块
在很多语言中都有函数的定义，但是在咱们JAVA语言中，我们将其称之为方法。
C:方法的格式:
修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2 ....){
方法体;
return 返回值;
}
D:方法的格式详细说明
(1): 修饰符 比较多,后面会详细介绍。目前使用 (权限修饰符)public static
(2): 返回值类型 用于限定返回值的数据类型
(3): 方法名 就是一个名称，它的存在是为了方便我们调用方法
(4): 参数类型 限定调用方法时传入参数的数据类型
(5): 参数名 是一个变量，接收调用方法时传入的参数
这个参数其实有一个专业的名词,被称之为形式参数,它的作用是用来接收实际参数的.
(6): 方法体 完成功能的代码
(7): return 结束方法以及返回方法指定类型的值
(8): 返回值 就是功能的结果，由return带回，带回给调用者
04.18_Java语言基础(方法之求和案例及其调用)
A:需求：求两个数据之和的案例
B:如何写一个方法
两个明确
(1):返回值类型 明确功能结果的数据类型
(2):参数列表 你要传递几个参数，以及每一个参数的数据类型
C:方法调用(有明确返回值的调用)
a:单独调用,一般来说没有意义，所以不推荐。
b:赋值调用,推荐方案。
c:输出调用,但是不够好。因为我们可能需要针对结果进行进一步的操作。
###04.19_Java语言基础(方法的调用图解)
A:画图演示
把刚才的的推荐调用方式画图解释
###04.20_Java语言基础(方法的练习)
A:案例演示
需求：获取两个数中的较大值
class FunctionTest {
public static void main(String[] args) {
// 获取两个数中的较大值
// 定义两个int类型的变量
int a = 500 ;
int b = 340 ;
// 赋值调用
int max = getMax(a , b);
System.out.println("max : " + max );
}
/*
获取两个数中的较大值
两个明确:
返回值类型: int
参数列表: int a , int b
*/
public static int getMax(int x , int y){
/*
int max = (x > y ) ? x : y;
return max ;
*/
return (x > y ) ? x : y;
}
}======================================================================
B:案例演示
需求：比较两个数是否相等
使用键盘录入改进
###04.21_Java语言基础(方法的注意事项)
A: 方法不调用不执行
B: 方法与方法是平级关系，不能嵌套定义
C: 方法定义的时候参数之间用逗号隔开
D: 方法调用的时候不用在传递数据类型
E: 如果方法有明确的返回值，一定要由return带回一个值
###04.22_Java语言基础(方法之输出星形及其调用)
A:案例演示
需求：根据键盘录入的行数和列数，在控制台输出星形
======================================================================
import java.util.Scanner;
class Demo {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入行数:");
int num1 = sc.nextInt();
System.out.println("请输入列数:");
int num2 = sc.nextInt();
print(num1 , num2);
}
public static void print(int a, int b){
for(int x=1;x<=a;x++){
for(int y=1;y<=b;y++){
System.out.print("*");
}
System.out.println();
}
}
}
======================================================================
B:方法调用：(没有明确返回值的调用)
单独调用
输出调用(错误)
赋值调用(错误)
###04.23_Java语言基础(方法的练习)
A:案例演示
需求：根据键盘录入的数据输出对应的乘法表
==================================================================
import java.util.Scanner;
class Demo {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入行数:");
int num1 = sc.nextInt();
System.out.println("请输入列数:");
int num2 = sc.nextInt();
print(num1 , num2);
}
public static void print(int a, int b){
for(int x=1;x<=a;x++){
for(int y=1;y<=b;y++){ //注意 a , b 的输入值和判断语句;
System.out.print(y+"*"+x+"="+y*x+"t");
}
System.out.println();
}
}
}
====================================================================
04.24_Java语言基础(方法重载概述和基本使用)
A:案例演示
求和案例
2个整数
3个整数
4个整数
/*求和案例
2个整数&3个整数&4个整数
*/
//方法重载
class Demo
{
public static void main(String[] args){
System.out.println(sum(12,34));
System.out.println(sum(12,34,37));
System.out.println(sum(12,34,11,68));
System.out.println(sum(1.2,3.4));
System.out.println(sum(1.2,34));
}
public static int sum(int a,int b){
System.out.println("两个int类型的参数的方法被调用了");
return a + b ;
}
public static int sum(int a , int b , int c){
return a + b + c ;
}
public static int sum(int a , int b , int c , int d ){
return a + b + c + d ;
}
public static double sum(double a , double b){
System.out.println("两个double类型的参数的方法被调用了");
return a + b ;
}
}
======================================================================
B:方法重载概述
在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同，与返回值无关。
参数列表不同：
A:参数个数不同
B:参数类型不同
最后
以上就是贪玩马里奥为你收集整理的Java_关键字&常量&变量&运算符&顺序结构语句的全部内容，希望文章能够帮你解决Java_关键字&常量&变量&运算符&顺序结构语句所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
![Day02--3继承、方法覆盖、多态、final、package、import、访问控制权限、IDEA快捷键1.继承2.方法覆盖/重写（override[官方]/overwrite）3.多态4.final关键字（最终的、不可变的）5.包机制（packet）6.import语句7.访问控制权限8.IDEA快捷键](/uploads/reation/bcimg1.png)
发表评论 取消回复