三目运算符
while 编写等腰三角形和直角三角形等
运算符
运算符就是对数据进行一些操作|运算的符号
赋值运算符
= : 赋值运算符， 将符号右边的数据，赋值给左边的变量
算数运算符
+, -, *, /, %, ++, --
+: 正号（单个数值）， 加法运算符（两个数值）， 字符串拼接符（只要有””字符串拼接符）
-: 负号， 减法运算符
*: 乘法
/ : 除法 如果只有整数参与运算，结果只保留整数
%:取余数
++ : 自增
基本含义：在整型的变量原来值的基础上加1，然后赋值给自己
++i: 前导自增
先将自己增加1，然后再进行其他运算（再使用）
i++: 后导自增
先进行其他运算（先使用），然后立刻马上自增1
-- : 自减
扩展运算符
作用：简写， 自动类型转换
扩展运算符是算术运算符和赋值运算符的简写形式
请将变量i的值，增大1个！！！
int i = 1;
i = i+1;
i++;
++i;
i += 1; // i = i+1
i += 5;
i *= 2;
+=, -=, *=, /=, %=
比较运算符
>, <, ==, !=, >=, <= 比较运算符得到的结果一定是一个布尔值
>,<,>=,<= 基本上只是针对数值型的数据进行运算，非数值型的数据，没有太多意义
==,!= 可以对任意类型的数据，进行判断
逻辑运算符
||, &&, !
运算数只能是逻辑类型，结果也是逻辑类型， 用来连接多个条件的。
b1 || b2 -> 只要存在true, 结果就为true
b1&&b2 -> 只要存在false, 结果就为false
!b -> true变false, false变true
双与和双或存在短路现象： 当表达式的结果一旦能够确定了，其后的所有操作将不再进行
位运算符
|, &
条件运算符
写法: 条件表达式 ?当条件表达式为true 结果表达式: 当条件表达式为false的结果表达式;
运算规则: 先计算条件表达式，选结果即可
例子三目运算符
/* 条件运算符： 三目运算符 条件表达式 ? 结果表达式1 : 结果表达式2 ; 1、计算条件表达式的结果 2、true 整个表达式的结果就为 结果表达式1的值 3、false整个表达式的结果就为 结果表达式2的值 */
public class Demo011Operator{
public static void main(String[] args){
// 判断这个数 是奇数还是偶数
int num1 = 11;
String str = num1%2!=0?"奇数":"偶数";
System.out.println(str);
// 60及格 ， 判断你的分数是否及格
int score = 59;
str = score>=60 ?"及格" :"不及格";
System.out.println(str);
// 判断一个数， 正数？ 负数？ 0
int num2 = 0;
// 判断是否是正数
str = num2>0 ? "正数" : (num2=0?"负数" :"零");
System.out.println(str);
}
}
public class Demo0010Operator{
public static void main(String[] args){
boolean gender = true;
System.out.println(gender);
// 如果gender== true 的话，就将 "男" 作为结果存储到str中， 否则就将 "女" 存储到str中
String str = gender ? "男" : "女";
System.out.println(str);
int num = 10;
// 判断num是不是0 ， 如果是0 打印 “零” ，否则打印“非零”
boolean flag = num ==0;
String r = flag ? "零" : "非零";
System.out.println(r);
System.out.println(num==0 ? "零": "非零");
}
}
选择
单选
只考虑这一种情况
if(条件表达式){
语句；
}
双选
考虑两种
if(条件表达式){
语句；
}else{
语句；
}
多选
考虑多种情况
if(条件表达式){
语句;
}else if(条件表达式){
语句；
}else {
语句；
}
switch
只能做定值选择
switch(值){
case 值1:语句;break;
case 值2:语句;break;
...
default: 语句；
}
说明：byte, short, int ,char, String
public static void main(String[] args) {
char oper = '-';
int num1 = 100;
int num2 = 10;
switch (oper){
case '+':
System.out.println(num1 + " + " + num2 + " = " + (num1+num2)); break;
case '-' :
System.out.println(num1 + " - " + num2 + " = " + (num1-num2));break;
case '*':
System.out.println(num1 + " * " + num2 + " = " + (num1*num2));break;
case '/':
System.out.println(num1 + " / " + num2 + " = " + (num1/num2));break;
case '%':
System.out.println(num1 + " % " + num2 + " = " + (num1%num2));break;
}
}
循环
重复做相同或者类似的操作
1、重复的动作
2、重复的次数或者结束重复的条件
while循环
while(循环的条件){
重复的操作；
}
死循环
while(true){
}
例子
public static void main(String[] args) {
int count = 0;
while(count<5){
System.out.println("* * * * *");
count++;
}
System.out.println("------第二种------");
count = 0;
while(count<5){ // 外层循环： 需要五颗星以及一个换行
// System.out.println("* * * * *");
int c = 0;
while(c<5){ // 内层循环： 一颗星以及一个空格
System.out.print("* ");
c++;
}
System.out.println();
count++;
}
}
打印如下
* * * * *
* * * * *
* * * * *
* * * * *
* * * * *
public static void main(String[] args) {
// 定义我的行数
int row = 1;
// 一共5行
while(row<=5){
// *
int col = 0;
while(col<row){
System.out.print("* ");
col++;
}
// 换行
System.out.println();
row++;
}
}
打印如下
*
* *
* * *
* * * *
* * * * *
public static void main(String[] args) {
// 定义的行数
int row = 1;
while(row<=5){
int r1 = 5;
// 循环打印空格
while(r1-row>=0){
System.out.print(" ");
r1--;
}
int r2=1;
// 循环打印*
while(r2<=row){
System.out.print("* ");
r2++;
}
// 换行
System.out.println();
row++;
}
}
打印如下
*
* *
* * *
* * * *
* * * * *
/** * 判断一个整数的位数 * 1、定义一个计数器 记录位 0 * 2、（只要这个数不为0）让这个数除以10 计数器+1 * 3、如果结果还是不为0 继续除以10 计数器+1 * * 一位数 只能除10依次 0 * 两位数 除两次10 0 * 三位数 除10三次 0 */
public class Demo008NumTest {
public static void main(String[] args) {
// 要判断的数据
int num = 0;
int back = num;
int count = 0;
// 除以10(缩小10倍) 并且把计数器++
// 循环的条件 num 0
while(num!=0){
num /= 10;
count++;
}
System.out.println(back + "是一个" + count + "位数");
}
}
break
break的含义是结束本层循环，从break的地方直接跳过本层循环 终止
continue
continue的含义是结束本层的本次循环，继续下一次循环 中止
例子
/** * 体测： * 一圈100米， 10圈完成考试 * continue 有的人在第4圈的时候摔了一跤， 从摔倒的地方扶起来，到起点重新开始跑，已经认为上一圈跑完了，继续下一圈 * break 有的人在第4圈的时候摔了一跤，晕了比较严重，来了两个同学直接抬走 */
public class Demo001BreakContinue {
public static void main(String[] args) {
// 计数器
int count = 0;
while(count<=10){
// 计数器开始计数
count++;
System.out.println("这是第 " + count + " 圈开始");
if(count==4){
//continue; // 轻轻摔一跤
break;
}
System.out.println("这是第 " + count + " 圈结束");
}
}
}
/** * 利用continue实现， 遇到能被7整除的数就跳过不打印 * * 利用break实现，遇到能被7整除的就停止打印 */
public class Demo002PrintNum {
public static void main(String[] args) {
int num = 1;
while(num<=100){
// 跳过不打印
if(num%7==0){
num++;
continue;
}
System.out.println(num);
num++;
}
System.out.println("------------------");
num = 1;
// 循环
while(num<=100){
// 遇到7， 跳过循环
if(num==7){
break;
}
System.out.println(num);
num++;
}
}
}
do-while 循环
也是重复做一些操作，特点在于，每一个循环至少走一次。
while 循环，先进行判断，然后再走循环
do-while先执行循环体，然后再判断是否要继续循环
do{
循环体
}while(条件表达式);
执行顺序：
1、执行循环
2、计算条件表达式，true 继续循环， false 结束循环
for循环
也是循环，重复执行一些操作，for循环经常适用于那些循环次数已经定好的情况；while一般适用于那些循环次数不定的情况
for( 初始表达式 ; 条件判断 ; 迭代因子){
循环体；
}
执行流程：
1、初始表达式
2、条件判断 true, false
3、如果条件表达式为true, 紧接着执行循环体
4、循环体执行完，执行迭代因子
5、迭代因子执行完以后，立刻执行条件判断
6、如果条件表达式为false 直接跳过整个循环
例子
/** * 打印【1，10】 * 【1，100】 * 1 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 */
public class Demo005ForLoop {
public static void main(String[] args) {
// 定义变量 num, 判断num<=10, 输出， num++, 判断
for(int num=1 ; num<=10 ; num++){
System.out.println(num);
}
System.out.println("-----------------------------");
for(int num = 1; num<=100; num++){
System.out.print(num + "\t");
if(num%10==0){
System.out.println();
}
}
}
}
打印如下
*
* *
* * *
* * * *
* * * * *
* * * * * *
* * * * * * *
* * * * * * * *
* * * * * * * * *
-------------
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
1 2 3 4 5 6 7
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8 9
-------------
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
public class Demo006ForLoop {
public static void main(String[] args) {
// 一共有多少行
for(int i=0;i<9;i++){
// 将一行的输出内容进行拆分
for(int j=0; j<=i; j++){
System.out.print("* ");
}
System.out.println();
}
System.out.println("-------------");
for(int i=1; i<=9; i++){
for(int j=1; j<=i; j++){
System.out.print(j + "\t");
}
System.out.println();
}
System.out.println("-------------");
for(int i=1; i<10; i++){
//每一行的内容
for(int j=1; j<=i; j++){
System.out.print(j + "*" + i + "=" + (i*j) + "\t");
}
// 换行 表示一行结束
System.out.println();
}
}
}
作用域
定义一个变量的时候： 类型， 名称，[值]
作用域就是变量的作用范围 {} 都会形成独立的作用域，在同一个作用域中，变量不能重名
一个变量的作用域，从定义的地方开始，到离与其前边最近的左大括号对应的右大括号结束
for循环中，括号里边的变量作用域只在for内部
练习：从键盘录入一个5位以内，包括5位的整数，通过程序判断这个数是几位数
将上面的那个整数，进行翻转 123 -> 321
1423 -> 142 -> 14 -> 1 -> 0
1 1 1 1
方法
方法的概念
方法|函数|功能： method|function
方法就是一些能够完成特定功能的代码集合。就是一块带名字的，可以让我们传入数据代码块。
代码块： {} 将多条语句组合成一个整体
名字：方便后期使用|定位到代码
() ：给完成功能代码提供原材料
返回值： 功能结束之后得到的结果
定义
定义方法创建方法
位置：类体中，所有方法之外
语法：
class 类名{
public static 返回值类型 方法名(形参列表){
方法体;
}
}
需求： 打印5次“HelloWorld”在屏幕上
class 类名{
public static void 方法名(){
}
}
调用
定义了一个方法并会执行，方法需要调用才会执行；调用方法就是使用方法。根据方法名找方法
方法名()；
方法的分类
参数
调用者给方法的数据。定义方法的时候，需要规定，调用者给的参数。 调用方法的时候，需要给出真实的数据
返回值
方法执行之后，得到的结果，可以有，也可以没有。定义方法的时候，告诉调用者我会不会给你数据，指定好类型；方法体中需要给出具体的返回值。调用时可以获得结果。
如果一个方法有返回值，就必须在方法体中使用 return关键字送出返回值。只要规定了有返回值，无论方法以哪种形式结束，都必须要给返回值
聊天：没有任何投入，也没有任何回报，聊完就完了 （无参无返回值）
借东西：不需要任何投入，获得一些东西 （无参有返回值）
买东西：需要原材料，同时能获得反馈 （有参有返回值）
送东西：只出不入 （有参无返回值）
说明:有没有参数和有没有返回值，完全没有什么关系，取决于功能|需求
定义方法确定如下内容即可：
根据需求明确方法取一个见名知意的名字
根据需求明确方法要完成的功能
根据需求明确方法要不要返回值 void (不要返回值)， 如果要需要指定类型(int ,double, boolean,String)
根据需求明确方法要不要参数 (), 个数以及对应的类型。 参数的含义
无参无返回值
打印目录的目录
public static void 方法名(){
}
方法名(); // 不能接收，也不能打印
带参无返回值
public static void 方法名(参数类型 参数名1, 参数类型 参数名2){
}
方法名(数据1， 数据2); // 不能接收，也不能打印
带参有返回值
public static 返回值类型 方法名(参数类型 参数名1){
return 数据;
}
返回值类型 变量名 = 方法名(数据1); // 可以接收，也可以打印
无参有返回值
public static 返回值类型 方法名(){
return 数据;
}
返回值类型 变量名 = 方法名(); // 可以接收，也可以打印
