Java中方法的创建,分支结构和循环结构
首先先说一下在Java中的逻辑运算符,便于后面的分支和循环的讲解
- 在逻辑运算符中需要注意到的点有以下几个:
- a++和++a的区别,他们两个的区别在于a++是先使用a的值a再自加,而++a是先自加再被程序所使用。两个的区别在于一个未变化就被使用,一个是变化后再被使用。
- 逻辑运算符中 双与(&&)和单与(&)的区别,逻辑运算大多数是用在后面的分支语句中用于判断,那么&&和&的区别在于当我使用&时,if判断需要对括号内两个条件进行判断当第一个条件为假时,它不会停止而是会继续将下一个条件进行判断。但是使用&&的话,在判断条件时,当第一个条件为假时,它会直接跳出或则结束判断而不会进行下一条件的判断,会节省很多时间。同样的双或(||)和单或(|)也是同样的道理,所以我们在更多时候会使用双与(&&)和双或(||)。
- 其次到三元运算符,三元运算符最大的作用就是用于三元表达式:1 ?2 :3,这个表示在1条件为真时,返回值为2或者执行2,1条件为假时,返回值为3或者执行3。其实三元表达式和if-else分支语句很相似,所以三元表达式还有一个重要的功能就是可以互相嵌套。比如:
//求三个数中的最大值
System.out.println("请输入三个数");
int b=new Scanner(System.in).nextInt();
int c=new Scanner(System.in).nextInt();
int d=new Scanner(System.in).nextInt();
//这里换成double5类型的数值也可以,没有限制
int max = b > c ? ( b > d ? b : d) : ( c > d ? c : d);
//最重要的在三元表达式的嵌套部分,它可以实现多次判断的相互嵌套,有这么一个思想是最好的。
System.out.println("最大值为:"+max);
运算符中比较特殊或者说有注意的点就我自己知道的这么几个。
分支语句if-else和switch-case(重点学习if-else分支语句)
-
if-else分支语句:单分支,多分支,嵌套分支
- 单分支:
if(判断条件){执行语句1;执行语句2;....}
- 多分支:
if(判断条件){满足条件时执行的代码块}else{条件不满足时执行的代码块}
- 嵌套分支:
if(判断条件1){满足条件时执行的代码块}else if(判断条件2){满足条件时执行的代码块}else if(判断条件3){满足条件时执行的代码块}else....
//单分支
if(判断条件1){
满足条件时要执行的代码块;
}
//多分支
if(判断条件1){
满足条件时要执行的代码块;
}else{
不满足条件时要执行的代码块;
}
//嵌套分支
//商品打折案例:
double c = new Scanner(System.in).nextDouble();
if(c>5000){
c = c*0.5;
}else if(c > 2000){
c = c*0.8;
}else if(c>1000){
c = c*0.9;
}
System.out.println(c);
int key = new Scanner(System.in).nextInt();//接收键盘输入的值
switch (key) {//将键盘输入的值传到switch中和下面的case的条件判断,满足谁就执行谁。
/*在使用switch时不仅仅只局限于数值。
switch(expr1)中,expr1是一个整数表达式,
整数表达式可以是int基本类型或Integer包装类型,
由于byte,short,char都可以隐含转换为int,所以也支持。在jdk1.7版本后也支持String类型的判断*/
case 1:
System.out.println("这是1时要输出的语句");
break;
case 2:
System.out.println("这是2时要输出的语句");
break;
case 3:
System.out.println("这是3时要输出的语句");
break;
default:
System.out.println("不满足时的输出");
break;
}
//在switch中不仅仅是一个匹配问题,当把每一项的break去掉以后,他就不是一个匹配问题,而是一个包含问题,就比如以上代码将break去掉以后,我输入一个2,那么最后的输出结果会是从2开始的3句话。所以这里的switch中不仅仅是匹配问题,还是一个包含问题。
循环结构for,while
- for循环:
for(开始条件;循环条件;更改条件){ 循环体代码… }
//打印九九乘法表案例
private static void f4() {
for (int i = 1; i < 9; i++) {//外循环,控制行,是一定的
for (int j = 1; j <= i; j++) {//内循环,列是不固定的,是递增的
System.out.print(i+"*"+j+"="+i*j+" ");//保证第一行打印出来一个*,注意条件
}
System.out.println();
}
}
/*这个是一个循环嵌套的案例,在使用循环嵌套,或者说在联系到数组后的循环我们都经常使用for循环来执行。*/
- while循环分为:单独的while(判断条件){执行的代码块},do{要执行大代码块}while(判断条件);—do-while的区别在于无论条件成不成立,都会将代码块先执行一遍,之后再进行判断。
//这里是一个死循环案例,没有什么特殊点,和for(;;)死循环不同的在于这个需要true才能判断死循环。
while(true){
System.out.println("这是一个死循环");
}
//从这个案例可以看出do-while循环是先执行一遍再进行循环判断。
int i = 0;
do {
i++;
System.out.println("i");
} while (i>2);
//这里突然想到一个问题,那我可不可以把int i = 0;放在循环体中呢?
do {
int i = 0;
i++;
System.out.println("i");
} while (i>2);
//其实这样是不行的,因为我的判断条件里的i是需要一个全局变量,而我的int i = 0;在循环体中是属于一个局部变量和判断条件中的i是不一样的;
方法的创建和调用
- 方法的创建:被命名的代码块,方法可以含参数可以不含参数可以提高代码的复用性。方法形式:
修饰符 返回值 方法名(【参数】){ 方法体; }
//方法的创建如下:
//在创建方法时,分为三个部分:修饰符 返回值 方法名(){},这个方法可以是有参的也可以是无参的函数
//void表示空,表示不需要返回值。
public void f(){
System.out.println("这是一个方法");
}
//方法创建的第二种类型,不需要修饰符,只是确定是否需要返回值
void f2(){
System.out.println("这是不含修饰符,只标明返回值的方法");
}
//第三种有参需要返回值的方法声明,主要的点在于最后需要return一个返回值。
public int f3(int a){
System.out.println("这是一个不需要void,但是需要返回值的类型");
return a;
}
//还有一种方法的声明方法是和类名同名的方法为构造方法
public class lianxi {
//在这里声明了一个空的构造方法。这种方法不需要修饰符和返回值等修饰,方法名也是固定的和类名一致。
lianxi(){}
}
- 方法的调用:方法的调用分为:
- 对象名.方法名;
- 类名.方法名;
- 方法名;(这个比较特殊,使用方法名直接调用时需要在方法声明时加上static关键字)
- new 构造方法名;
public class Ff {
public static void main(String[] args) {
// TODO Auto-generated method stub
Ff f = new Ff();//创建一个对象,使用对象调用方法
f.h2();
new Ff().h2();//上面两行代码也可以直接简写成这样,它的意思也是new一个对象去调用方法
//类名调用方法名,这个也需要在方法声明时加上static关键字
Ff.h3();
//方法名调用方法,直接使用方法名调用方法,主要也是要加上static关键字
h1();
}
public static void h1(){
System.out.println("方法名直接调用:");
}
public void h2(){
System.out.println("对象名调用方法");
}
public static void h3(){
System.out.println("类名调用方法");
}
}
public class Ff {
public static void main(String[] args) {
// TODO Auto-generated method stub
Ff f = new Ff();//创建一个对象,使用对象调用函数
f.h2();
new Ff().h2();//上面两行代码也可以直接简写成这样,它的意思也是new一个对象去调用函数
//类名调用函数名,这个也需要在函数声明时加上static关键字
Ff.h3();
//方法名调用函数,直接使用方法名调用方法,主要也是要加上static关键字
h1();
//new调用构造方法
new gzff();
}
public static void h1(){
System.out.println("函数名直接调用:");
}
public void h2(){
System.out.println("对象名调用函数");
}
public static void h3(){
System.out.println("类名调用函数");
}
}
class gzff{
gzff(){
System.out.println("new 调用构造方法");
}
}
在这里解释一下,为什么那个构造方法我要重新写一个类来实现,是因为我第一次写构造方法调用后发现,只要每一个使用Ff();的地方,我的构造方法都会被调用,意思是上面的代码中,无论是Ff a = new Ff(); a.h1();
还是new Ff().h1;
都会调用构造方法,输出一句“构造方法已被使用”。
个人觉得方法以及方法写好以后封装,在之后的Java学习中是最常用到,所以应该要形成一个写方法的习惯。不能所有代码都在主函数中实现。