Java学习笔记——Java本身、基础语法、键盘录入、分支、循环-CSDN博客

本文链接：https://blog.csdn.net/keadou/article/details/139300888

Java相关

简介

1.Java是1991年sun公司推出的
2.Java之父：詹姆斯·高斯林（James Gosling）
3.Java的logo：小咖啡杯
4.Java所属的公司：sun——Oracle

版本分类

1.JavaSE
两大功能：
（1）是JavaME和JavaEE的基础（重要）
（2）可以用来进行桌面开发（已弃用）
【1】界面不美观（颜值）
【2】如果渲染一些比较复杂的动画，会出现卡顿（性能）
AWT、GUI —— 桌面开发、不用学
2.JavaME（不学）
小型设备开发：手机、pad、机顶盒.etc
诺基亚——塞班系统——打开小游戏——弹出一个小咖啡杯
安卓——H5（前端）
3.JavaEE（重要）
用来作为大型服务器开发
Q：什么是服务器？
A：app与商家之间的中转站

三个版本间的关系

JavaSE 是基础，在此基础上延伸出了 JavaME 和 JavaEE 这两个分支

Java的特点

跨平台

在不修改源代码的情况下，同一个Java文件，可以在任意的操作系统中正常运行
- 原理
  
  JVM（Java虚拟机）
  针对不同的操作系统，有不同版本的虚拟机
  原理：虚拟机运行在操作系统中，java文件运行在虚拟机上

JDK、JRE、JVM

JDK

Java development kit：Java开发工具集
特点：可开发、可运行
作用：一般给Java开发人员使用
JRE

Java Runtime Environment：Java运行环境
特点：只能运行，不能开发
作用：给想要运行Java程序的用户使用的
JVM

Java Virtual Machine：Java虚拟机
特点：在不同的操作系统中，都有不同版本的虚拟机
总结：JDK 包含 JRE，JRE 包含 JVM
- 三大任务
  - 加载
    
    JVM 将字节码文件（.class文件）加载进内存，再将 .class 文件转换成可以执行的机器码，存储到 JVM 的方法区。
  - 验证
    
    JVM 对加载的字节码进行验证，以确保符合 Java 的语言规范和 JVM 规范，包含类型检查.etc 。
  - 执行
    
    JVM 执行已经加载和验证的字节码文件。

开发第一个Java程序

底层原理

三个步骤

编写代码——编译代码——运行代码

编写代码

public class HelloWorld{
	public static void main(String[] args){
		System.out.println("Hello World!");
	}
}

分析
- public class HelloWorld
  
  表示定义一个类，其中HelloWorld是类的名字
- public static void main(String[] args)
  
  表示定义一个方法，方法的名字是main
- System.out.println(“Hello World!”);
  
  表示在控制台输出小括号里面的内容

编译代码（javac命令）

javac helloworld.java

现象

将 .java结尾的文件转成了 .class文件（字节码文件）
本质

.java ——> .class
原因

因为 JVM 只能认识 .class ，不认识 .java
总结

.java——给程序员看的
.class——给虚拟机看的

运行代码（java命令）

java helloworld

现象

将代码结果放在cmd命令行中
分析

其实运行的是编译之后的 .class 文件

Idea

一个专门针对Java的集成开发工具

使用原因

Java程序开发三步骤：编写代码（.java）——> 编译代码（javac）——>运行代码（java）

把编写代码、编译代码、运行代码等多种功能都综合到一起

初次使用步骤

1、创建一个项目（project）
2、打开项目结构，设置SDK
3、创建一个Java类型的module
4、使用Idea实现HelloWorld项目
（1）在src文件中创建一个包com.Idea ——包名命名规则：域名反写
（2）在包中创建一个类，类名为HelloWorld，每个类都是平级的，不能在类里创建类
5、使用快捷键生成相应的代码
6、一键编译和运行

案例

 package com.Idea;
  /*
  * 快捷键：
  *   多行注释---- ctrl + shift + /
  *   单行注释---- ctrl + /
  *   main方法---- psvm
  *   控制台打印---- sout
  */
  public class HelloWorld {
      //main方法
      public static void main(String[] args) {
          //定义一个String类的字符串
          String c1 = "Miko";
          //在控制台打印结果
          System.out.println("HelloWorld"+" "+c1);
      }
  }

键盘录入

步骤：
1、导包
import java.util.Scanner;
2、创建键盘录入对象
Scanner sc = new Scanner(System.in);
3、通过键盘录入对象获取键盘输入的值
int s = sc.nextint();

实例1

package com.Idea;
import java.util.Scanner;
/*
*   测试键盘录入
* */
public class ScannerDemo1 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个数字：");
        //接受从键盘中输入的数字
        int i = sc.nextInt();// ctrl+alt+v

        //输出
        System.out.println("您输入的数字为："+i);
    }
}

实例2

package com.Idea;
import java.util.Scanner;
/*
* Scanner练习
*   键盘录入三个数字，输出其中的最小值
* */
public class ScannerDemo2 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        //输入三个数字
        System.out.println("请输入第一个数字：");
        int i1 = sc.nextInt();
        System.out.println("请输入第二个数字：");
        int i2 = sc.nextInt();
        System.out.println("请输入第三个数字：");
        int i3 = sc.nextInt();
        //判断最小值
        int min = i1 < i2 ? i1 : i2;
        min = min < i3 ? min : i3;
        System.out.println("最小值为"+min);//格式化 ctrl + alt + L
    }
}

分支

if

if单选结构
- 实例

package com.Idea;
	  import java.util.Scanner;
	  /*
	  * 测试if分支结构
	  * */
	  public class IfDemo1 {
	      public static void main(String[] args) {
	          //if单选结构
	          //键盘录入一个年龄，如果大于等于18，则输出成年
	  
	          //创建键盘录入对象
	          Scanner sc = new Scanner(System.in);
	          System.out.println("请输入一个年龄：");
	  
	          //接收键盘输入的值
	          int age = sc.nextInt();
	          //if单选结构
	          if(age >= 18){
	              System.out.println("已成年");
	          }
	      }
	  }

if双选结构
- 实例

 package com.Idea;
	  import java.util.Scanner;
	  /*
	  * 测试if双选结构
	  * */
	  public class IfDemo2 {
	      public static void main(String[] args) {
	          //键盘一个数字，判断数字是否在5-10之间
	          //创建键盘录入对象
	          Scanner sc = new Scanner(System.in);
	          System.out.println("请输入一个数字：");
	          //接收键盘录入的值
	          int i = sc.nextInt();
	          //if双选结构
	          if (i >=5 && i<=10){
	              System.out.println("在5-10之间");
	          }else {
	              System.out.println("不在5-10之间");
	          }
	      }
	  }

if多选结构
- 实例

 package com.Idea;
	  import java.util.Scanner;
	  /*
	  * 测试if多选结构
	  * */
	  public class IfDemo3 {
	      public static void main(String[] args) {
	          //键盘输入一个学生的成绩，如果大于等于90——优秀，如果大于等于70——良好
	          //如果大于等于60——及格，否则——不及格
	          //创建键盘录入对象
	          Scanner sc = new Scanner(System.in);
	          System.out.println("请输入一个成绩：");
	          //接收输入的成绩
	          int score = sc.nextInt();
	          //使用if多选结构进行判断
	          if (score >=90){
	              System.out.println("优秀");
	          }else if (score >=70){
	              System.out.println("良好");
	          }else if (score >=60){
	              System.out.println("及格");
	          }else{
	              System.out.println("不及格");
	          }
	      }
	  }

switch

case后面必须要添加break
格式：
switch(表达式){
case 常量 :
执行语句
break;
case 常量 :
执行语句
break;
default:
执行语句;
break;
}

实例

package com.Idea;
  import java.util.Scanner;
  /*
  * 测试switch语句
  * 键盘输入一个整数月份
  * 3 4 5——春季
  * 6 7 8——夏季
  * 9 10 11——秋季
  * 12 1 2——冬季
  * */
  public class SwitchDemo1 {
      public static void main(String[] args) {
          //创建键盘录入对象
          Scanner sc = new Scanner(System.in);
          System.out.println("请输入一个月份");
          //接收键盘录入的值
          int month = sc.nextInt();
          //使用switch实现判断季节的需求
          switch (month){
              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;
          }
      }
  }

分析

表达式：取值只能是byte、short、int、char，JDK5以后可以是枚举，JDK7以后可以是String（面试题）

case：后面跟的是和表达式比较的常量，数据类型要和表达式相同

case穿透：case后面不加break时，会继续运行下一个case的执行语句，直到遇到break或者switch语句运行结束

break：结束switch语句

default：以上的case都不匹配，则执行default中的内容

循环

for循环（重要）

实例1

 package com.Idea;
  /*
  * 测试for循环
  * */
  public class ForDemo1 {
      public static void main(String[] args) {
          //在控制台输出1,2,3,4....100
          //fori快捷输入for循环
          //100.fori快速输入0-100的for循环
          for (int i = 1; i <= 100; i++) {
              System.out.println(i);//复制当前行 ctrl+d
          }
      }
  }

实例2

package com.Idea;
  /*
  * 练习for循环
  *       求和思想----统计思想
  *       1+2+3+...+100
  * */
  public class ForDemo2 {
      public static void main(String[] args) {
          int sum = 0;
          for (int i = 1; i <= 100; i++) {
              sum += i ;
          }
          System.out.println(sum);
      }
  }

while循环（重要）

格式：
初始化语句:
while(条件判断语句){
循环体语句;
条件控制语句;
}

实例

package com.Idea;
  /*
      测试while循环
          初始化语句;
  		while(条件判断语句){
  				循环体语句;
  				条件控制语句;
  		}
  * */
  public class WhileDemo1 {
      public static void main(String[] args) {
          //统计思想：求1-100之间能被3整除的数的个数
          int total = 0;
          //使用while循环来完成需求
          int start = 1;
          while(start <= 100){
              if (start%3 == 0){ //表示可以被3整除
                  total++;//++total;也可以
              }
              start++;
          }
          System.out.println(total);
      }
}

do…while循环（了解）

格式：
初始化语句:
do{
循环体语句;
条件控制语句;
}while(条件判断语句);

实例

package com.Idea;
  /*
     测试do...while循环
  		初始化语句:
  		do{
  				循环体语句;
  				条件控制语句;
  		}while(条件判断语句);
  */
  public class DoWhileDemo1 {
      public static void main(String[] args) {
          //统计思想：求1-100之间能被3整除的数的个数
          int total = 0;
          //使用while循环来完成需求
          int start = 1;
          do{
              if (start%3 == 0){ //表示可以被3整除
                  total++;//++total;也可以
              }
              start++;
          }
          while(start <= 100);
          System.out.println(total);
      }
  }

控制跳转

两个关键字：
break：结束整个循环
continue：跳过一次循环，进入下一次循环

实例

package com.Idea;
  /*
  * 循环控制
  *       continue
  *       break
  * */
  public class ForDemo3 {
      public static void main(String[] args) {
          //在控制台打印1，2，3，...，100，其中55不打印
          for (int i = 1; i < 101; i++) {
              if (i == 55){
                  continue;//跳过一次循环
              }
              System.out.println(i);
          }
          //在控制台打印1，2，3，...，100，其中55及以后不打印
          for (int i = 1; i < 101; i++) {
              if (i == 55){
                  break;//结束循环
              }
              System.out.println(i);
          }
      }
  }

Java的基础语法

注释（掌握）

1、概述
注释是对程序的解释说明。
电脑——说明书（注释）
2、特点
注释不参与程序的运行，起到说明作用。

分类

（1）单行注释
// 注释的内容
（2）多行注释
/* 注释的内容 /
（3）文档注释（目前用不上）
/* 注释的内容 **/
要求：以后写代码一定要加注释

关键字

1、概念
在 Java 中，把赋予了特殊含义的单词，称为关键字
Java 中：单词（关键字）——特殊含义
2、特点
（1）关键字的单词字母全部小写
（2）在 notepad++ 中，关键字有高亮显示

常量

在程序运行的过程中，值不可以发生改变的量

分类
- 字符串常量
  
  使用双引号引起来的
  （单引号（ ’ ’ ）双引号（ " " ）反引号——键盘上波浪线英文输入（ `` ））
- 整数常量
  
  不带小数的一个数字
- 小数常量
  
  带小数的数字
- 字符常量
  
  【1】使用单引号引起来的
  【2】单引号中只能有一个字符（英文、中文、符号）
- 布尔常量
  
  只有两个量：true、false
- 空常量
  
  只有一个特殊的值：null
- 实例

/*
	  	测试Java中的常量
	  */
	  public class Demo1{
	  	public static void main(String[] args){
	  		//字符串常量
	  		System.out.println("南京");
	  		System.out.println("JAVA");
	  		//整数常量
	  		System.out.println(1024);
	  		System.out.println(-12);
	  		//小数常量
	  		System.out.println(10.24);
	  		System.out.println(-36.52);
	  		//字符常量
	  		System.out.println('刚');
	  		System.out.println('好');
	  		//布尔常量
	  		System.out.println(true);
	  		System.out.println(false);
	  		//空常量
	  		//System.out.println(null); //null 值不能直接打印
	  	}
	  }

数据类型

作用：Java是一种强类型语言，Java中的数据必须要先明确类型，然后才能使用

基本数据类型
- 数据类型
  
  byte、short、int、long
- 浮点数类型
  
  float、double
- 字符
  
  char
- 布尔类
  
  boolean
引用数据类型
- 类
- 接口
- 数组

变量

在程序的运行过程中，值在一定范围内可以发生改变的量
结论：数值可以变，类型不能变

赋值和声明

方式一：推荐使用
数据类型变量名 = 值 ;
方式二：能看懂就行
数据类型变量名 ;
变量名 = 值 ;
方式三：能看懂就行
数据类型变量名1 , 变量名2 , 变量名3 , … ;
变量名1 = 值1 ;
变量名2 = 值2 ;
变量名3 = 值3 ;
深入理解

 /*
  	变量的演示
  */
  public class Demo3{
  	public static void main(String[] args){
  		//声明byte类型的变量：
  		byte b1 = 10;
  		System.out.println(b1);
  		//声明short类型的变量：
  		short s1 = 100;
  		System.out.println(s1);
  		//声明int类型的变量：
  		int i1 = 1000;
  		System.out.println(i1);
  		//声明long类型的变量：
  		long l1 = 10L;
  			/*右侧10默认为int类型
  			long类型的数据在末尾要加上L或者l，推荐使用L
  			*/
  		System.out.println(b1);
  		//声明float类型的变量：
  		float f1 = 12.34F;
  			/*右侧12.34默认为double类型
  			float类型的数据在末尾要加上F或者f，推荐使用F
  			*/
  		System.out.println(f1);
  		//声明double类型的变量：
  		double d1 = 12.345;
  		System.out.println(d1);
  		//声明char类型的变量：
  		char c1 = 'a';
  		System.out.println(c1);
  		//声明boolean类型的变量：
  		boolean bl1 = true;//同一个方法内，变量名不能重复
  		System.out.println(b1);
  		
  		//测试：变量只申明，不赋值，能不能打印（使用）？
  		//变量在使用之前一定要赋值
  	}
  }

标志符号

给类名、变量、方法名、包含命名的符号

标识符命名规则

【1】必须由字母、数字、下划线（_）、美元符号（$）组成
【2】不能以数字开头
【3】区分大小写，长度无限制
【4】不能是Java中的关键字
使用规范

（1）大驼峰：类名，接口名
每个单词的首字母大写
Hello,Hellojava
（2）小驼峰：方法名、变量名
第一个单词首字母小写，从第二个单词开始，每个单词首字母大写
（3）常量名：常量
所有字母大写
TOTAL、MAX_AGE

类型转换

原因

在做计算的时候，需要保证数据类型相同
byte b1 = 10 ;
10默认是 int 类型，而左边是 byte 类型，所以内部存在类型转换
两种方式
- 自动类型转换（隐式转换）
  
  容量小的数据类型可以自动转成容量大的数据类型
  转换规则：
  （1）byte、short、char——int——long——float——double
  （2）byte、short、char三者之间不会相互转换，计算的时候会直接都转成int类型
  （3）byte、short、char属于自动类型转换的特例，只要不超过其表示范围即可
  - 实例

/*
		  	测试自动类型转换
		  	转换规则：
		  （1）byte、short、char——int——long——float——double
		  （2）byte、short、char三者之间不会相互转换，计算的时候会直接都转成int类型
		  （3）byte、short、char属于自动类型转换的特例，只要不超过其表示范围即可
		  */
		  public class Demo4{
		  	public static void main(String[] args){
		  		//byte——>int
		  		byte a1=3;
		  		int a2=4;
		  		a2=a1;
		  		System.out.println(a2);
		  		//short——>int
		  		short b1=3;
		  		int b2=4;
		  		b2=b1;
		  		System.out.println(b2);
		  		//char——>int
		  		char c1='a';//'a'——97	'A'——65		'0'——48		ASCII码
		  		int c2=100;
		  		c2=c1;
		  		System.out.println(c2);
		  		//int——>long
		  		int d1=3;
		  		long d2=4L;
		  		d2=d1;
		  		System.out.println(d2);
		  		//long——>float
		  		long e1=100L;
		  		float e2=122.34F;
		  		e2=e1;
		  		System.out.println(e2);
		  		//float——>double
		  		float f1=12.5F;
		  		double f2=45.6;
		  		f2=f1;
		  		System.out.println(f2);
		  		
		  		//特殊的自动类型转换
		  		byte g1=10;
		  		short g2=100;
		  		//byte g3 = 1234; int 自动转byte，值不能超过byte的范围
		  		System.out.println(g1);
		  		System.out.println(g2);
		  	}
		  }

强制类型转换

把容量大的转成容量小的数据类型
格式：
目标数据类型变量名 = ( 目标数据类型 ) 值或者变量
缺点：强制类型转换可能会造成精度丢失

实例

/*
		  	强制类型转换的两个案例
		  */
		  public class Demo5{
		  	public static void main(String[] args){
		  		//不丢失精度
		  		long l1=100L;
		  		int l2=(int)l1;
		  		System.out.println(l2);
		  		//丢失精度
		  		float a=12.345F;
		  		byte byte1=(byte)a;
		  		System.out.println(byte1);//12
		  	}
		  }

运算符和表达式

运算符：对常量或者变量进行操作的符号
int a = 10 ; = 为运算符
表达式：用运算符把常量或者变量连接起来，并且符合Java语法的式子
int c = a + b ; a + b 是表达式

算数运算符

四则运算
- 实例

/*
	  	测试算数运算符
	  */
	  public class Demo1{
	  	public static void main(String[] args){
	  		int a=10;
	  		int b=3;
	  		//加
	  		System.out.println(a+b);
	  		//减
	  		System.out.println(a-b);
	  		//乘，Java中乘号使用*
	  		System.out.println(a*b);
	  		//除，Java中除号使用/
	  		System.out.println(a/b);//商，因为输入int为整数类，输出结果为整数
	  		//float和double 类是不准确的，例如：10.0/3=3.33335
	  		
	          //取余，Java中取余使用%
	  		System.out.println(a%b);
	  	}
	  }

+操作
- 字符的+操作
  - 实例

/*
		  	测试字符+操作——>ASCII码
		  */
		  public class Demo2{
		  	public static void main(String[] args){
		  		char c1='a';//a——97——>98
		  		System.out.println(c1+1);
		  		
		  		char c2='A';//A——65
		  		System.out.println(c2+1);
		  		
		  		char c3='0';//a——48
		  		System.out.println(c3+1);
		  	}
		  }

字符串的+操作

实例

 /*
		  	测试字符串+操作
		  */
		  public class Demo3{
		  	public static void main(String[] args){
		  		System.out.println(1+99+"南京");//字符串中+，表示拼接
		  		System.out.println(3+4+"南京"+1+2);//结果为“7南京12”，“7南京”为字符串，+1、+2都为拼接
		  		System.out.println(3+4+"南京"+(1+2));//结果为“7南京3”
		  	}
		  }

赋值运算
- 实例

 /*
	  	测试赋值运算符号
	  */
	  public class Demo4{
	  	public static void main(String[] args){
	  		int a=10;
	  		int b=3;
	  		/*
	  		以下语句测试时需要按条依次测试
	  		每次计算后a、b值都会发生变化，测试结果不直观
	  		*/
	  		System.out.println(a += b);//a += b	——>		a = a + b
	  		System.out.println(a -= b);//a -= b	——>		a = a - b
	  		System.out.println(a *= b);//a *= b	——>		a = a * b
	  		System.out.println(a /= b);//a /= b	——>		a = a / b
	  		System.out.println(a %= b);//a %= b	——>		a = a % b
	  	}
	  }

自增自减运算符

自增（++）：自动加 1
自减（–）：自动减 1
- 实例

/*
	  	测试自增自减运算符
	  */
	  public class Demo5{
	  	public static void main(String[] args){
	  		int a=10;
	  		int b=3;
	  		//使用自增运算符
	  		a++;//++a; 在此处二者结果一致
	  		System.out.println(a);
	  		//实际操作时只写a++或者++a，不需要考虑赋值先后的两种情况
	          
	  		int j = a++;//++在后，++操作后计算
	  		System.out.println(a);//11，a++已经计算出结果
	  		System.out.println(j);//10，先赋值，a再++
	  		
	  		//int j=++a;//++在前，++操作先计算
	  		//System.out.println(a);//11，++a已经计算出结果
	  		//System.out.println(j);//11，先++，再赋值
	  	}
	  }

关系运算符

= != < <= > >=
oracle中关系运算符可以拆开，mysql和Java不可以拆开
- 实例

/*
	  	测试关系运算符
	  */
	  public class Demo6{
	  	public static void main(String[] args){
	  		int a=10;
	  		int b=20;
	  		System.out.println(a == b);
	  		System.out.println(a != b);
	  		System.out.println(a > b);
	  		System.out.println(a >= b);
	  		System.out.println(a < b);
	  		System.out.println(a <= b);
	  		//输出false或者true
	  	}
	  }

逻辑运算符

与& 或| 非! 异或^
短路与&& 短路或||
- 实例

 /*
	  	测试逻辑运算符
	  */
	  public class Demo7{
	  	public static void main(String[] args){
	  		int a=10;
	  		int b=20;
	  		//输出false或者true
	  		System.out.println(a > 5 & b < 10);//false,两个都为true，才输出true
	  		System.out.println(a > 5 | b < 10);//true，有一个为true，就输出true
	  		System.out.println(!(a > 5));	  //false，取反
	  		System.out.println(a > 5 ^ b < 10);//true，相同为false，不同为true
	  		//测试短路与和短路或
	  		int x=3;
	  		int y=4;
	  		//短路与
	  		//System.out.println((x++) > 4 & (y++) < 5);//测试时这两行需要分行测试，否则x++和y++已经改变x与y的值
	  		System.out.println((x++) > 4 && (y++) < 5);
	  		System.out.println(x);
	  		System.out.println(y);
	  		/*短路或
	  		//System.out.println((x++) > 3 | (y++) < 4);
	  		System.out.println((x++) > 3 || (y++) < 4);
	  		System.out.println(x);
	  		System.out.println(y);
	  		*/
	  	}
	  }

分析

  a > 10 & b <20		：两边都会执行
  
  a > 10 && b <20	 ：&表示两个都是true，结果才是true；&&表示若左侧为false，则不计算右边
  
  a > 10 | b <20		：两边都会执行
  
  a > 10 || b <20	 ：|表示一个是true，结果就是true；||表示若左侧为true，则不计算右边

位运算符（了解）

<< >>
例如：4 >> 1：将 4 的二进制向右移动1位（除以2）
0100（4）——> 0010（2）
理解方法：向左移一位即为乘以2，向右移一位则为除以2
- 实例

/*
	  	测试位运算符
	  */
	  public class Demo8{
	  	public static void main(String[] args){
	  		int a = 3 << 2;// 0011 ——> 1100（12）
	  		System.out.println(a);
	  		
	  		int b = 4 >> 2;// 0100 ——> 0001（1）
	  		System.out.println(b);
	  	}
	  }

三元运算符（三目运算符）

格式：
布尔表达式？表达式一：表达式二;
例如：
a > b ? a : b ;
先判断a>b是否为真
真：返回a
假：返回b
- 实例

 /*
	  	测试三元运算符
	  */
	  public class Demo9{
	  	public static void main(String[] args){
	  		int a = 50;
	  		int b = 20;
	  		int c = a > b ? a : b;
	  		System.out.println(c);
	  		
	  		//练习
	  		//定义两个变量，判断两个变量是否相等
	  		int d = 50;
	  		int e = 80;
	  		boolean f = d == e ? true : false;
	  		//d == e ? true : false;一整句为一个整体
	  		System.out.println(f);
	  		
	  		//定义三个变量，求三个数中的最大值
	  		int i1 = 30;
	  		int i2 = 20;
	  		int i3 = 10;
	  		int i4 = i1 > i2 ? i1 : i2;
	  		int max = i3 > i4 ? i3 : i4;
	  		System.out.println(max);
	  	}
	  }