文章目录
1.逻辑与或和短路与或的区别
/*
逻辑与和短路与的区别：逻辑与2个语句都执行，短路与中若第一个为false,则第二个不用执行，判定语句为false.
逻辑或和短路或的区别：逻辑或2个语句都执行，短路或中第一个为true,则第二个语句不执行，判定语句为true.
异或运算：相同为false，不同为true.
*/
public class yunsuanfu
{
public static void main(String[] args)
{
int x=10;
int y=8;
System.out.println(x<y&&++x<y);//短路与，第一个是false,故第二个语句不执行,结果是false
System.out.println(x);//10，第二个语句不执行
System.out.println(x<y&++x<y);//逻辑与两个都执行，x<y是false,11<8是false,结果是false
System.out.println(x);//11，第二个语句执行
System.out.println(x>y||++x<y);//短路或，第一个语句为true,故++x<y不执行，结果为true
System.out.println(x);//11，第二个语句不执行
System.out.println(x>y|++x<y);//逻辑或是两个语句都执行，x>y是true,12<8是false,结果为true
System.out.println(x);//12,第二个语句执行
System.out.println(x<y^++x<y);//12<8^13<8,布尔型值都为1，相同为false.
}
}
2.连接符"+"
/*数字+数字–>数字，【求和】；
数字+“字符串”–>“字符串”【连接符】
*/
public class LianJieFu
{
public static void main(String[] args)
{
System.out.println(10+20);//30
System.out.println(10+20+"30");//3030,自左向右计算，先算10+20为30，后面“30”是字符串，故+为连接符，3030是字符串
System.out.println(10+(20+"30"));//102030,先算括号里2030为字符串，连接10，为102030为字符串
int a=10;
int b=20;
System.out.println("10+20="+a+b);//10+20=1020
System.out.println("10+20="+(a+b));//10+20=30
System.out.println(a+"+"+b+"="+(a+b));//10+20=30，动态的a+b=30
String username="zhangsan";
System.out.println("登陆成功，欢迎"+username+"回来");//登陆成功，欢迎zhangsan回来
}
}
3.三目运算符：布尔表达式？表达式1：表达式2
public class SanMuYunSuanFu
{
public static void main(String[] args)
{
boolean sex=false;
char c=sex?'男':'女';
System.out.println(c);//女
sex=true;//可以重复名，是boolean;如果是String sex=true就错了，变量名不重复
c=(sex?'男':'女');
System.out.println(c);//男
String s=(sex?"男的":"女的");//sex的值为true,就近原则
System.out.println(s);//男的
System.out.println(sex?'男':"女");//男
System.out.println(10);
System.out.println("10");
System.out.println('2');
}
}
4.键盘输入命令
public class ShuRu
{
public static void main(String[] args)
{
java.util.Scanner s=new java.util.Scanner(System.in);//键盘输入命令符
String userInputContent=s.next();//键盘等待输入字符串
System.out.println("您输入的是："+userInputContent);
int num=s.nextInt();//键盘等待输入整型数字
System.out.print("你输入的数字是："+num);
}
}
5. If语句
(1)
public class IfYuJu
{
public static void main(String[] args)
{
java.util.Scanner s=new java.util.Scanner(System.in);//键盘输入命令语句
System.out.print("您输入的年龄是:");
int age=s.nextInt();//此处可以输入数字
String str="老年";//开始的默认值
/*下面就是if语句*/
if(age<0||age>150){
str="您提供的年龄不合法，年龄值需要在0~150之间";
}else if(age<5){
str="幼儿";
}else if(age>=5&&age<10){
str="少年";
}else if(age<=18){
str="青少年";
}else if(age<=35){
str="青年";
}else if(age<=55){
str="中年";
}else{
str="老年";
}
System.out.println("您处于生命周期的"+str+"阶段");
}
}
(2)
/if语句的嵌套模式，此例结构复杂，所以缩进一定要对其/
public class IfYuJu02
{
public static void main(String[] args)
{
java.util.Scanner s=new java.util.Scanner(System.in);//键盘输入语句
System.out.println("欢迎使用本系统，您通过本系统可以完成一些简单的判断");
System.out.println("说明1:1表示下雨，0表示晴天");
System.out.println("说明2:1表示男，0表示女");
System.out.println("说明3:温度为数字");
System.out.print("请输入性别:");//接收性别
int sex=s.nextInt();
System.out.print("请输入当前天气状况:");
int weather=s.nextInt();//接收天气状况
//判断天气状况
if(weather==1){
System.out.println("下雨天");
if(sex==1){
System.out.println("带一把大黑伞");
}else if(sex==0){
System.out.println("带一把大花伞");
}else{
System.out.println("对不起，您输入的性别有错误");
}
}else if(weather==0){
System.out.println("晴天");
System.out.println("请输入当前天气的温度:");
int tem=s.nextInt();
if(tem>30&&tem<40){
if(sex==1){
System.out.println("戴墨镜");
}else if(sex==0){
System.out.println("擦防晒霜");
}else{
System.out.println("对不起，您输入的性别有错误");
}
}else{
System.out.println("输入的天气状况不符合");
}
}else{
System.out.println("对不起，您输入的天气状况不存在！");
}
}
}
6. switch语句
(1)switch语句的3种形式：普通，透传，合并;
switch(int或string类型)
case(int或string类型)
byte/short/char也可以，会自动转int类型,但其他类型需要强制类型转换
结果：请输入正整数：1
星期一
==========================================
星期一
星期二
星期三
==========================================
星期一
请输入正整数：0
对不起，您输入的信息有误
==========================================
对不起，您输入的信息有误
==========================================
星期一
/*** Switch语句的三种形式 ***/
public class Switch
{
public static void main(String[] args)
{
java.util.Scanner s=new java.util.Scanner(System.in);
System.out.print("请输入正整数：");
int num=s.nextInt();
switch(num)
{
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("==========================================");
/*以下是Switch语句的透传模式，输入数字1、2、3到break前都输出*/
switch(num)
{
case 1:
System.out.println("星期一");
case 2:
System.out.println("星期二");
case 3:
System.out.println("星期三");//前面的语句都是缺少break语句，输入数字在3之前都是输到星期三为止
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("==========================================");
/**** 这是Switch语句的合并功能，就是几个case语句输出相同的结果 *****/
switch(num)
{
case 1: case 0: case 8:
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;
}
}
}
(2)
结果：欢迎来到加减乘除取余计算界面：
请输入第一个数字:2
请输入运算符：*
请输入第二个数字：32
电脑计算的结果为:2*32=64
欢迎来到加减乘除取余计算界面：
请输入第一个数字:24
请输入运算符：/
请输入第二个数字：12
电脑计算的结果为:24/12=2
public class Switch02
{
public static void main(String[] args)
{
java.util.Scanner s=new java.util.Scanner(System.in);
System.out.println("欢迎来到加减乘除取余计算界面：");
System.out.print("请输入第一个数字:");
int num1=s.nextInt();
System.out.print("请输入运算符：");
String operate=s.next();
System.out.print("请输入第二个数字：");
int num2=s.nextInt();
int result=0;
switch(operate)
{
case "+":
result=num1 + num2;
break;
case "-":
result=num1 - num2;
break;
case "*":
result=num1 * num2;
break;
case "/":
result=num1 / num2;
break;
case "%":
result=num1 % num2;
break;
default:
System.out.println("您输入的运算符不符合要求，不能计算！！！");
}
System.out.println("电脑计算的结果为:"+num1+operate+num2+"="+result);
}
}
7. for循环语句
/*打印9*9乘法表
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
*/
public class For
{
public static void main(String[] args){
for(int i=1;i<=9;i++){
for(int j=1;j<=i;j++){
System.out.print(i+"*"+j+"="+(i*j)+" ");//最后的“ ”是空格
}
System.out.print("\n");//System.out.println();//外层循环需转9次行
}
}
}
8. break、continue语句
这个程序会出3种形式的结果，以分隔符为界限，break，continue，还有for1：，for2的break循环。
public class Break
{
public static void main(String[] args){
for(int i=0;i<3;i++){
for(int j=0;j<10;j++){
if(j==5){
break;//就近原则，终止内层for循环。
}
System.out.println("-->"+j);
}
System.out.println();
}
System.out.println("=========================");
/**********这是不常用的一种写法，外层起名for1，内层循环起名for2
***********/
for1:for(int i=0;i<3;i++){
for2:for(int j=0;j<10;j++){
if(j==5){
break for1;//这是另一种不常用写法，break终止外层for循环,for1。
}
System.out.println("-->"+j);
}
System.out.println();
}
System.out.println("Hello World!");
System.out.println("==================================");
for(int i=0;i<3;i++){
for(int j=0;j<10;j++){
if(j==5){
continue;//结束j==5的循环，循环继续执行
}
System.out.println("-->"+j);
}
System.out.println();
}
System.out.println("Hello World!");
}
}
9. 0到100的素数
结果：
2是素数 3是素数 4不是素数 5是素数 6不是素数 7是素数 8不是素数 9不是素数
10不是素数 11是素数 12不是素数 13是素数 14不是素数 15不是素数 16不是素数
17是素数 18不是素数 19是素数 20不是素数 21不是素数 22不是素数 23是素数
24不是素数 25不是素数 26不是素数 27不是素数 28不是素数 29是素数 30不是素数
31是素数 32不是素数 33不是素数 34不是素数 35不是素数 36不是素数 37是素数
38不是素数 39不是素数 40不是素数 41是素数 42不是素数 43是素数 44不是素数
45不是素数 46不是素数 47是素数 48不是素数 49不是素数 50不是素数 51不是素数
52不是素数 53是素数 54不是素数 55不是素数 56不是素数 57不是素数 58不是素数
59是素数 60不是素数 61是素数 62不是素数 63不是素数 64不是素数 65不是素数
66不是素数 67是素数 68不是素数 69不是素数 70不是素数 71是素数 72不是素数
73是素数 74不是素数 75不是素数 76不是素数 77不是素数 78不是素数 79是素数
80不是素数 81不是素数 82不是素数 83是素数 84不是素数 85不是素数 86不是素数
87不是素数 88不是素数 89是素数 90不是素数 91不是素数 92不是素数 93不是素数
94不是素数 95不是素数 96不是素数 97是素数 98不是素数 99不是素数 100不是素数
素数：2 3 5 7 11 13 17 19
23 29 31 37 41 43 47 53
59 61 67 71 73 79 83 89
97
public class SuShu
{
public static void main(String[] args){
for(int i=2;i<=100;i++){
boolean s=true;//设定默认值，每次外循环重新赋值一遍
for(int j=2;j<i;j++){//素数是1和它本身不需要，所以从2到它前面一位
if(i%j==0){//进行除法运算，
s=false;
break;
}
}
System.out.println(s?i+"是素数":i+"不是素数");//s的判断取决于开始的true还是后面的if语句中的false
}
System.out.println("-------------------------------------------------------");
int count=0;//【统计机制，默认count值为0】
for(int i=2;i<=100;i++){
boolean s=true;//设定默认值，每次外循环重新赋值一遍
for(int j=2;j<i;j++){//素数是1和它本身不需要，所以从2到它前面一位
if(i%j==0){//进行除法运算，
s=false;
break;
}
}
if(s){
System.out.print(i+" ");//输出100之内的素数
count++;
if(count%8==0)
{
System.out.println();//8个一行素数换行输出
}
}
}
}
}
10.方法（函数）
(1)方法调用
/*
1.这个是方法调用的例子：【修饰符】返回类型 方法名（形参列表）；
2.修饰符列表中有static关键字，则调用时“类名.”可以省略不写,但仅限在本类，其他类必须加，不然访问错误；
3.形参与实参个数要相同，数据类型要相同，不同需自动转换或强制类型转换；
4.按顺序执行，先从主方法main开始，遇到调用方法，则先暂停主，跳入各个方法中执行，此例结果
22+33=55
do some!!!
2+90=92
do some!!!
AAA
5
I’M a student!
*/
public class FangFa
{
public static int sum(int a,int b){
int c=a+b;
System.out.println(a+"+"+b+"="+(a+b));
FangFa.dosome();
return c;//int类型必须要返回值
}
public static void main(String[] args){
sum(22,33);//先暂停此行，跳入sum执行，接着执行dosome，之后这行执行完毕，执行下一行。||省略类名.
sum(2,90);//先暂停此行，跳入sum执行，接着执行dosome，之后这行执行完毕，执行下一行。||省略类名.
A.doother();//调用其他类的方法，不管有没有static关键字，必须加"类名."。
divide(20L,4);//int自动转换成long类型，小转大，||divide(20L,4L);divide(20,4);
System.out.println("I'M a student!");
}
public static void dosome(){
System.out.println("do some!!!");
}
public static long divide(long a,long b){//b中int类型的4已经自动转换成long类型
long c=a/b;//这里a、b、c可以与sum方法中的重复，因为所属不同方法。
System.out.println(c);
return 1;//long类型必须加return 返回值；，否则编译错误||return 0;
}
}
class A//重新定义一个类A
{
public static void doother(){
System.out.println("AAA");
return;//void类型，可以加“return;”返回，也可以不加return返回，但是不能加“retunr 值；”返回，不然报错
}
}
(2)方法重载
/* 方法重载：当功能相似的时候，尽可能让方法名相同； 条件：（1）在同一个类中；（2）方法名相同；（3）参数列表不同：数量不同，顺序不同，类型不同 结果：101 2.8
2.3 2
21 34.4
*/
public class ChongZai
{
public static void main(String[] args){
m1();
m1(10);
m2(1,2.8);
m2(2.3,2);
m3(21);
m3(34.4);
//m4(1,2);
//m4(2,5);
}
//以下两个方法构成重载,参数列表数量不同
public static void m1(){}
public static void m1(int a){
System.out.println(a);
}
//以下两个方法构成重载，参数列表顺序不同
public static void m2(int a,double b){
System.out.print(a+" ");
System.out.println(b);
}
public static void m2(double a,int b){
System.out.print(a+" ");
System.out.println(b);
}
//以下两个方法构成重载，参数列表类型不同
public static void m3(int x){
System.out.print(x+" ");
}
public static void m3(double x){
System.out.println(x);
}
//以下两个方法不构成重载，编译报错，方法发生重复
/*public static void m4(int a,int b){}
public static void m4(int b,int a){}
*/
}
(3)方法封装
/*方法封装：以后写程序用到相似的可以直接调用，不用再写一遍，生成class文件，相当于SUN公司定义的class文件一样. 结果：A
123
78.3
123
true
I Love China
100
Hello World!!
C
100.34
调用两个自定义的方法封装库U.class,工具.class,自己查看文件U.java和文件工具.java */
public class FengZhuang
{
public static void main(String[] args){
U.p('A');
U.p(123);
U.p(78.3);
U.p(123L);
U.p(true);
U.p("I Love China");
System.out.println("===============================");
工具.打印(100);
工具.打印("Hello World!!");
工具.打印('C');
工具.打印(100.34);
}
}
//自定义类U，相当于SUN公司定义的类，封装U，生成U.class文件，以后都可以调用，只要程序与该文件一起
/*class U
{
public static void p(byte b){
System.out.println(b);
}
public static void p(short b){
System.out.println(b);
}
public static void p(int b){
System.out.println(b);
}
public static void p(long b){
System.out.println(b);
}
public static void p(float b){
System.out.println(b);
}
public static void p(double b){
System.out.println(b);
}
public static void p(char b){
System.out.println(b);
}
public static void p(String b){
System.out.println(b);
}
public static void p(boolean b){
System.out.println(b);
}
}*/
//自定义class工具，封装成库
/* class 工具
{
public static void 打印(byte data){
System.out.println(data);
}
public static void 打印(short data){
System.out.println(data);
}
public static void 打印(int data){
System.out.println(data);
}
public static void 打印(long data){
System.out.println(data);
}
public static void 打印(float data){
System.out.println(data);
}
public static void 打印(double data){
System.out.println(data);
}
public static void 打印(char data){
System.out.println(data);
}
public static void 打印(String data){
System.out.println(data);
}
public static void 打印(boolean data){
System.out.println(data);
}
}*/
下面是自己封装的2个库，以后写的程序只要保存在该class文件所在的地方，就可以直接调用，如上述就是调用的U.class和工具.class
/*自定义类U，相当于SUN公司定义的类，封装U，生成U.class文件，以后都可以调用，只要程序与该文件一起
*/
public class U
{
public static void p(byte b){
System.out.println(b);
}
public static void p(short b){
System.out.println(b);
}
public static void p(int b){
System.out.println(b);
}
public static void p(long b){
System.out.println(b);
}
public static void p(float b){
System.out.println(b);
}
public static void p(double b){
System.out.println(b);
}
public static void p(char b){
System.out.println(b);
}
public static void p(String b){
System.out.println(b);
}
public static void p(boolean b){
System.out.println(b);
}
}
public class 工具
{
public static void 打印(byte data){
System.out.println(data);
}
public static void 打印(short data){
System.out.println(data);
}
public static void 打印(int data){
System.out.println(data);
}
public static void 打印(long data){
System.out.println(data);
}
public static void 打印(float data){
System.out.println(data);
}
public static void 打印(double data){
System.out.println(data);
}
public static void 打印(char data){
System.out.println(data);
}
public static void 打印(String data){
System.out.println(data);
}
public static void 打印(boolean data){
System.out.println(data);
}
}
(4)方法递归
1)/*
方法递归调用：自己调用自己，但可能耗内存，以下2种方法进行比较
结果：
5050
5050
*/
public class FangfaDigui
{
public static void main(String[] args){
int n=100;
int result=sum(n);//调用sum
int jieguo=sumint(n);//调用sumint
System.out.println(result);
System.out.println("============================");
System.out.println(jieguo);
}
//不用方法递归计算
public static int sum(int n){
int s=0;
int i;
for(i=1;i<=n;i++){
s+=i;
}
return s;
}
//用方法递归计算
public static int sumint(int n){
if(n==1){
return 1;//该方法结束
}
return n+sumint(n-1);//递归调用sum方法
}
}
2)
/*面试题
方法递归调用：自己调用自己，但可能耗内存，以下2种方法进行比较
结果：
3628800
3628800
*/
public class FangfaDigui02
{
public static void main(String[] args){
int n=10;
long result=sum(n);//调用sum,n=10是int类型，调用时自动转换成long
long jieguo=sumint(n);//调用sumint,n=10是int类型，调用时自动转换成long
System.out.println(result);
System.out.println("============================");
System.out.println(jieguo);
}
//不用方法递归计算
public static long sum(long n){
long s=1;
long i;
for(i=1;i<=n;i++){
s*=i;
}
return s;
}
//用方法递归计算
public static long sumint(long n){
if(n==1){
return 1;//该方法结束
}
return n*sumint(n-1);//递归调用sum方法
}
}
