java基础知识2,java基础知识3

java-02-java基础知识2,java-02-java

第02天 java基础知识

前天内容介绍

u  Eclipse的设置、配置及运用

u  运算符

u  键盘录入

第02天 java基础知识

第02天 java基础知识

第03天 java基础知识

第1章   Eclipse开荒工具

明日内容介绍

今天内容介绍

明日内容介绍

1.1  Eclipse概述和安装

Eclipse是二个IDE(集成开拓条件)IDE(Integrated Development Environment)

合併了代码编写成效,剖判效果与利益,编写翻译作用,调节和测验功效等全体的开拓软件。

Eclipse的特征描述:无偿、纯Java语言编写、免安装、增加性强

下载和装置、下载

设置:棕色类版、解压就能够动用(Eclipse)

u  Eclipse的安装、配置及应用

u Eclipse的设置、配置及运用

u  选取流程序调控制语句

1.2  Eclipse的核心使用

u  运算符

u 运算符

u  循环流程序调控制语句

1.2.1 Eclipse基本操作

选料专业空间

职业空间  其实就是我们写的源代码所在的目录

用Eclipse来变成叁个HelloWorld案例

A:创造Java项目:点击File大概在最侧面空白处,选拔Java项目,在分界面中写一个项目名称,然后Finish就可以。

       B:创设包:展开项目,在源包src下树立三个包com.itheima

       C:成立类:在com.ithiema包下创建三个类HelloWorld

在分界面中写七个类名:HelloWorld,然后finish就能够。

D:编写代码:在HelloWorld类写main方法,在main方法中写

一条出口语句:笔者是黑马技术员,小编骄傲,笔者自豪。

       E:编写翻译:自动编写翻译,在保留的那一刻帮您做好了

       F:运维     选取要运转的文本大概在要运营的公文内容中

                     右键 — Run as – Java Application即可

u  键盘录入

u 键盘录入

u  调整循环语句

1.2.2 代码案例一

package com.itheima;

 

public class HelloWorld {

    public static void main(String[] args) {

        System.out.println(“作者是黑马程序猿,小编骄傲,作者自豪”);

    }

}

 

第1章   Eclipse开垦工具

第1章 Eclipse开荒工具

第1章   选用流程序调整制语句

1.3      Eclipse专门的学问空间的主旨配置

       A:行号的显得和掩盖

              展现:在代码区域的最左侧的空域区域,右键 — Show Line
Numbers就能够。

              隐蔽:把上面的动作再做一回。

       B:字体大小及颜色

              a:Java代码区域的字体大小和颜料:

window — Preferences — General — Appearance — Colors And Fonts —
Java — Java Edit Text Font

              b:控制台

window — Preferences — General — Appearance — Colors And Fonts —
Debug — Console font

              c:其余文件

window — Preferences — General — Appearance — Colors And Fonts —
Basic — Text Font

       C:窗体给弄乱了,如何做?

              window — Perspective — Reset Perspective     

       D:调控台找不到了,咋做?

              Window–Show View—Console

1.1  Eclipse概述和设置

Eclipse是一个IDE(集成开垦条件)IDE(Integrated Development Environment)

购并了代码编写功用,剖析效果与利益,编写翻译作用,调节和测验成效等一体化的开荒软件。

Eclipse的表征描述:免费、纯Java语言编写、免安装、扩展性强

下载和安装、下载

设置:水绿版、解压就可以运用(Eclipse)

1.1 Eclipse概述和设置

Eclipse是一个IDEIDE(Integrated Development Environment)

合併了代码编写作用,深入分析效益,编写翻译作用,调节和测量试验效率等总体的开辟软件。

Eclipse的性状描述:免费、纯Java语言编写、免安装、扩充性强

下载和安装、下载

安装:莲灰版、解压就能够利用

1.1  顺序结构的中坚选取

1.4  Eclipse中协理键和快速键的采纳

1.2  Eclipse的大旨选取

1.2 Eclipse的主干选择

1.1.1 顺序结构概述

是程序中最简易最宗旨的流水生产线调整,未有一定的语法结构,依照代码的先后顺序,依次施行,程序中多数的代码都是如此推行的

1.4.1 常用支持键和快速键概述

剧情帮忙键    alt+/

main      然后alt+/

syso       然后alt+/

 

快捷键

注释

单行       选中内容,ctrl+/, 再来三次打消

多行       选中剧情,ctrl+shift+/, ctrl+shift+\

格式化           ctrl+shift+f

1.2.1 Eclipse基本操作

选用专门的学问空间

做事空间  其实便是大家写的源代码所在的目录

用Eclipse来产生叁个HelloWorld案例

A:创制Java项目:点击File只怕在最侧边空白处,接纳Java项目,在分界面中写多少个项目名称,然后Finish就能够。

       B:创立包:展开项目,在源包src下树立三个包com.itheima

       C:创制类:在com.ithiema包下创立几个类HelloWorld

在分界面中写二个类名:HelloWorld,然后finish就可以。

D:编写代码:在HelloWorld类写main方法,在main方法中写

一条出口语句:笔者是黑马程序猿,笔者骄傲,笔者自豪。

       E:编译:自动编写翻译,在保存的那一刻帮您搞好了

       F:运营     选拔要运营的文件恐怕在要运营的文书内容中

                     右键 — Run as – Java Application即可

1.2.1 Eclipse基本操作

挑选职业空间

做事空间 其实正是我们写的源代码所在的目录

用Eclipse来完毕二个HelloWorld案例

A:创建Java项目:点击File也许在最左侧空白处,选用Java项目,在分界面中写三个项目名称,然后Finish即可。

B:创设包:展开项目,在源包src下创设二个包com.itheima

C:创制类:在com.ithiema包下创立一个类HelloWorld

在分界面中写四个类名:HelloWorld,然后finish就能够。

D:编写代码:在HelloWorld类写main方法,在main方法中写

一条出口语句:作者是黑马技术员,笔者骄傲,笔者自豪。

E:编写翻译:自动编写翻译,在保存的那一刻帮您做好了

F:运维 接纳要运行的文本可能在要运维的文本内容中

右键 — Run as – Java Application即可

1.1.2 顺序流程流程图

 

1.4.2 代码案例二

package com.itheima_02;

/*

 * 内容匡助键:alt+/

 *      A:main方法

 *          main,然后alt+/,回车

 *      B:输出语句

 *          syso,然后然后alt+/,回车

 *

 * 快捷键:

 *      A:注释

 *          单行 选中剧情,ctrl+/,再来一遍就是撤除

 *          多行 选取内容,ctrl+shift+/,ctrl+shift+\

 *      B:格式化

 *          ctrl+shift+f

 */

public class HelloWorld {

    public static void main(String[] args) {

        System.out.println(“HelloWorld1”);

        System.out.println(“HelloWorld2”);

        System.out.println(“HelloWorld3”);

        System.out.println(“HelloWorld4”);

        System.out.println(“HelloWorld5”);

    }

}

 

1.2.2 代码案例一

java基础知识2,java基础知识3。package com.itheima;

 

public class HelloWorld {

    public static void main(String[] args) {

        System.out.println(“笔者是黑马程序猿,笔者骄傲,作者自豪”);

    }

}

 

1.2.2 代码案例一

package com.itheima;

public class HelloWorld {

public static void main(String[] args) {

System.out.println(“小编是黑马程序猿,笔者骄傲,小编自豪”);

}

}

1.1.3 代码案例一

package com.itheima_01;

 

/*

 * 顺序结构:从上往下,依次实践

 */

public class OrderDemo {

    public static void main(String[] args) {

        System.out.println(“开始”);

        System.out.println(“语句A”);

        System.out.println(“语句B”);

        System.out.println(“语句C”);

        System.out.println(“结束”);

    }

}

 

1.5  Eclipse中项指标删除和导入

       A:删除项目

              选中项目 – 右键 – 删除

              从品种区域中删去

              从硬盘上剔除

       B:导入项目

              在档案的次序区域右键找到import

              找到General,展开,并找到

              Existing Projects into Workspace

              点击next,然后选用你要导入的项目

              注意:这里选拔的是项目名称

 

 

1.3      Eclipse专门的职业空间的主干配置

       A:行号的来得和潜伏

              显示:在代码区域的最侧面的空白区域,右键 — Show Line
Numbers就可以。

              遮盖:把地点的动作再做三回。

       B:字体大小及颜色

              a:Java代码区域的字体大小和颜色:

window — Preferences — General — Appearance — Colors And Fonts —
Java — Java Edit Text Font

              b:控制台

window — Preferences — General — Appearance — Colors And Fonts —
Debug — Console font

              c:其他文件

window — Preferences — General — Appearance — Colors And Fonts —
Basic — Text Font

       C:窗体给弄乱了,如何是好?

              window — Perspective — Reset Perspective     

       D:调节台找不到了,如何是好?

              Window–Show View—Console

1.3 Eclipse专门的学问空间的主导配置

A:行号的呈现和隐身

体现:在代码区域的最侧面的空域区域,右键 — Show Line Numbers就可以。

隐身:把下面的动作再做三次。

B:字体大小及颜色

a:Java代码区域的字体大小和颜色:

window — Preferences — General — Appearance — Colors And Fonts —
Java — Java Edit Text Font

b:控制台

window — Preferences — General — Appearance — Colors And Fonts —
Debug — Console font

c:其他文件

window — Preferences — General — Appearance — Colors And Fonts —
Basic — Text Font

C:窗体给弄乱了,咋做?

window — Perspective — Reset Perspective

D:调整台找不到了,如何是好?

Window–Show View—Console

1.2  If语句的格式

第2章   运算符

1.4  Eclipse中扶助键和快速键的行使

1.4 Eclipse中扶助键和急迅键的使用

1.2.1 If语句格式1及实践流程

if语句第一种格式:

if(关系表明式) {

                   语句体

       }

实践流程:

第一剖断关系表明式看其结果是true依旧false

假使是true就实施语句体

假定是false就不实行语句体

2.1  算数运算符

  • 运算符

对常量和变量进行操作的符堪称为运算符

  • 表达式

用运算符把常量只怕变量连接起来符号java语法的架子就足以叫做表明式。分歧运算符连接的姿势浮现的是区别品种的表明式。

概念多少个int类型的变量a,b,做加法(a + b)

  • 常用运算符

算术运算符

赋值运算符

关系运算符

逻辑运算符

元春运算符

 

1.4.1 常用协理键和连忙键概述

内容帮助键    alt+/

main      然后alt+/

syso       然后alt+/

 

快捷键

注释

单行       选中剧情,ctrl+/, 再来三回吊销

多行       选中内容,ctrl+shift+/, ctrl+shift+\

格式化           ctrl+shift+f

1.4.1 常用协助键和急忙键概述

内容扶助键 alt+/

main 然后alt+/

syso 然后alt+/

快捷键

注释

单行 选中内容,ctrl+/, 再来贰遍吊销

多行 选中剧情,ctrl+shift+/, ctrl+shift+\

格式化 ctrl+shift+f

1.2.2 if语句格式1实行流程图

 

2.1.1 算数运算符的基本用法

1.4.2 代码案例二

package com.itheima_02;

/*

 * 内容辅助键:alt+/

 *      A:main方法

 *          main,然后alt+/,回车

 *      B:输出语句

 *          syso,然后然后alt+/,回车

 *

 * 快捷键:

 *      A:注释

 *          单行 选中内容,ctrl+/,再来一回正是收回

 *          多行 选拔内容,ctrl+shift+/,ctrl+shift+\

 *      B:格式化

 *          ctrl+shift+f

 */

public class HelloWorld {

    public static void main(String[] args) {

        System.out.println(“HelloWorld1”);

        System.out.println(“HelloWorld2”);

        System.out.println(“HelloWorld3”);

        System.out.println(“HelloWorld4”);

        System.out.println(“HelloWorld5”);

    }

}

 

1.4.2 代码案例二

package com.itheima_02;

/*

* 内容协理键:alt+/

* A:main方法

* main,然后alt+/,回车

* B:输出语句

* syso,然后然后alt+/,回车

*

* 快捷键:

* A:注释

* 单行 选中内容,ctrl+/,再来一回就是打消

* 多行 选用内容,ctrl+shift+/,ctrl+shift+\

* B:格式化

* ctrl+shift+f

*/

public class HelloWorld {

public static void main(String[] args) {

System.out.println(“HelloWorld1”);

System.out.println(“HelloWorld2”);

System.out.println(“HelloWorld3”);

System.out.println(“HelloWorld4”);

System.out.println(“HelloWorld5”);

}

}

1.2.3 代码案例二

package com.itheima_02;

/*

 * if语句有二种格式。

 *

 * if语句格式1:

 *      if(关系表达式) {

 *          语句体;

 *      }

 *

 * 执行流程:

 *      A:首先剖断关系表明式看其结果是true依旧false

 *      B:假设是true,就实践语句体

 *      C:假若是false,就不奉行语句体

 */

public class IfDemo {

    public static void main(String[] args) {

        System.out.println(“开始”);

        // 定义多个变量

        int a = 10;

        int b = 20;

 

        if (a == b) {

            System.out.println(“a等于b”);

        }

 

        int c = 10;

        if (a == c) {

            System.out.println(“a等于c”);

        }

 

        System.out.println(“结束”);

    }

}

2.1.2 算数运算符概述

 A:什么是运算符

        正是对常量和变量进行操作的符号。

B:算数运算符有哪些

       * +,-,*,/,%,++,– 

1.5  Eclipse中项指标去除和导入

       A:删除项目

              选中项目 – 右键 – 删除

              从类型区域中去除

              从硬盘上剔除

       B:导入项目

              在类型区域右键找到import

              找到General,展开,并找到

              Existing Projects into Workspace

              点击next,然后选拔你要导入的种类

              注意:这里选取的是项目名称

 

 

1.5 Eclipse中项指标删减和导入

A:删除项目

入选项目 – 右键 – 删除

从项目区域中除去

从硬盘上删除

B:导入项目

在等级次序区域右键找到import

找到General,展开,并找到

Existing Projects into Workspace

点击next,然后选择你要导入的连串

留意:这里采用的是项目名称

1.2.4 If语句格式2及实践流程

if语句第三种格式:

if(关系表明式) {

                   语句体1;

       }else {

                   语句体2;

       }

实施流程

第一判别关系表明式看其结果是true照旧false

假使是true就推行语句体1

譬喻是false就推行语句体2

2.1.3 代码案例三

package com.itheima_01;

/*

 * 运算符:对常量和变量进行操作的标志

 *
表明式:用运算符连接起来的合乎java语法的架子。不一致等级次序的运算符连接起来的姿势是不一样的表明式。

 *      比如:定义多少个int类型的变量a,b,

 *          a + b

 *

 * 运算符分类:

 *      算术运算符,赋值运算符,关系运算符,逻辑运算符,莫斯利安运算符。

 *

 * 算术运算符:

 *      +,-,*,/的宗旨选择

 */

public class OperatorDemo {

    public static void main(String[] args) {

        // 定义四个变量

        int a = 3;

        int b = 4;

 

        System.out.println(a + b);

        System.out.println(a – b);

        System.out.println(a * b);

        System.out.println(a / b);

 

        // 整数相除只好获得整数,要想猎取小数,就必得有浮点数参加运算

        System.out.println(3 / 4.0);

        System.out.println(3.0 / 4);

    }

}

 

第2章   运算符

第2章 运算符

1.2.5 if语句格式2试行流程图

 

2.1.4 算数运算符取余和除法的界别

 %:取余运算符。获得的是四个相除数据的余数。

 /:除法运算符。拿到是五个相除数据的商。

 使用处境: %:推断多个数据是或不是整除。

2.1  算数运算符

  • 运算符

对常量和变量举行操作的标识称为运算符

  • 表达式

用运算符把常量可能变量连接起来符号java语法的姿势就能够称呼表明式。分化运算符连接的姿态呈现的是不相同档案的次序的表明式。

概念多少个int类型的变量a,b,做加法(a + b)

  • 常用运算符

算术运算符

赋值运算符

论及运算符

逻辑运算符

新禧初中一年级运算符

 

2.1 算数运算符

  • 运算符

对常量和变量实行操作的暗堪称为运算符

  • 表达式

用运算符把常量大概变量连接起来符号java语法的架势就可以称之为表明式。差异运算符连接的架子呈现的是不一致档案的次序的表达式。

概念三个int类型的变量a,b,做加法

  • 常用运算符

算术运算符

赋值运算符

涉嫌运算符

逻辑运算符

新禧初中一年级运算符

1.2.6 代码案例三

package com.itheima_02;

/*

 * if语句格式2:

 *      if(关系表明式) {

 *          语句体1;

 *      }else {

 *          语句体2;

 *      }

 *

 * 试行流程:

 *      A:判别关系表明式的值是true照旧false

 *      B:假若是true,就进行语句体1

 *      C:假使是false,就推行语句体2

 */

public class IfDemo2 {

    public static void main(String[] args) {

        System.out.println(“开始”);

        // 判定给定的数目是奇数依然偶数

        // 定义变量

        int a = 100;

        // 给a重新赋值

        a = 99;

 

        if (a % 2 == 0) {

            System.out.println(“a是偶数”);

        } else {

            System.out.println(“a是奇数”);

        }

 

        System.out.println(“结束”);

    }

}

2.1.5 代码案例四

public class OperatorDemo2 {

    public static void main(String[] args) {

        int a = 5;

        int b = 3;

 

        System.out.println(a / b);

        System.out.println(a % b);

    }

}

 

2.1.1 算数运算符的主干用法

2.1.1 算数运算符的中坚用法

1.2.7 If语句格式3及进行流程

 

if语句第二种格式:

if(关系表达式1) {

                   语句体1;

       }else  if (关系发布式2) {

                   语句体2;

       }

    …

       else {

                   语句体n+1;

       }

进行流程

先是判定关系表明式1看其结果是true依然false

假要是true就实践语句体1

倘诺是false就一而再判定关系表明式2看其结果是true依旧false

要是是true就实行语句体2

若是是false就一连判别关系发挥式…看其结果是true还是false

一经未有别的关联表明式为true,就实践语句体n+1

2.1.6 字符和字符串出席加法操作

字符参预运算

实质上是拿该字符对应的数值来操作

‘a’     97

‘A’     65

‘0’     48

字符串加入运算

此间实在做的不是加法运算,而是字符串拼接。

字符串和别的门类的多少做拼接,结果是字符串类型的。

2.1.2 算数运算符概述

 A:什么是运算符

        正是对常量和变量实行操作的标识。

B:算数运算符有哪些

       * +,-,*,/,%,++,– 

2.1.2 算数运算符概述

A:什么是运算符

固然对常量和变量进行操作的号子。

B:算数运算符有哪些

* +,-,*,/,%,++,–

1.2.8 if语句格式3实行流程图

 

2.1.7 代码案例五

package com.itheima_01;

/*

 * 整数的加法。

 * 字符到场加法操作。拿字符在管理器中底层存款和储蓄对应的数据值来插手运算的。

 *      ‘0’     48

 *      ‘a’     97

 *      ‘A’     65

 * 字符串参预加法操作。

 *      这里的+其实不是加法,而是字符串连接符。

 */

public class OperatorDemo3 {

    public static void main(String[] args) {

        // 整数加法

        int a = 10;

        int b = 20;

        System.out.println(a + b);

        System.out.println(“——————“);

 

        // 字符参预加法操作

        char c = ‘0’;

        char c2 = ‘a’;

        System.out.println(a + c);

        System.out.println(a + c2);

        System.out.println(“——————“);

 

        // 字符串到场加法操作

        System.out.println(“hello” + a);

        System.out.println(“hello” + a + b); //
“hello”+10,然后再和b实行拼接

        System.out.println(a + b + “hello”);

    }

}

 

2.1.3 代码案例三

package com.itheima_01;

/*

 * 运算符:对常量和变量进行操作的标志

 *
表达式:用运算符连接起来的契合java语法的架势。差别品种的运算符连接起来的架子是分裂的表达式。

 *      例如:定义多少个int类型的变量a,b,

 *          a + b

 *

 * 运算符分类:

 *      算术运算符,赋值运算符,关系运算符,逻辑运算符,伊利运算符。

 *

 * 算术运算符:

 *      +,-,*,/的中央接纳

 */

public class OperatorDemo {

    public static void main(String[] args) {

        // 定义八个变量

        int a = 3;

        int b = 4;

 

        System.out.println(a + b);

        System.out.println(a – b);

        System.out.println(a * b);

        System.out.println(a / b);

 

        // 整数相除只可以取得整数,要想获取小数,就必得有浮点数参与运算

        System.out.println(3 / 4.0);

        System.out.println(3.0 / 4);

    }

}

 

2.1.3 代码案例三

package com.itheima_01;

/*

* 运算符:对常量和变量进行操作的暗号

*
表明式:用运算符连接起来的适合java语法的姿态。分化门类的运算符连接起来的架势是分歧的表明式。

* 举例:定义多少个int类型的变量a,b,

* a + b

*

* 运算符分类:

* 算术运算符,赋值运算符,关系运算符,逻辑运算符,长富运算符。

*

* 算术运算符:

* +,-,*,/的中央使用

*/

public class OperatorDemo {

public static void main(String[] args) {

// 定义多少个变量

int a = 3;

int b = 4;

System.out.println;

System.out.println;

System.out.println;

System.out.println;

// 整数相除只可以得到整数,要想获得小数,就务须有浮点数加入运算

System.out.println;

System.out.println;

}

}

1.2.9 代码案例四

package com.itheima_02;

 

/*

 * if语句格式3:

 *      if(关系表明式1) {

 *          语句体1;

 *      }else if(关系发挥式2) {

 *          语句体2;

 *      }else if(关系表达式3) {

 *          语句体3;

 *      }

 *      …

 *      else {

 *          语句体n+1;

 *      }

 *

 * 推行流程:

 *      A:首先决断关系表明式1看其结果是true依旧false

 *      B:假设是true,就实行语句体1

 *     
     假使是false,就连任开展关联发布式2的决断看其结果是true照旧false

 *      C:要是是true,就实施语句体2

 *     
   如若是false,就此起彼伏进行关联发挥式…的论断看其结果是true依旧false

 *      …

 *      D:若无贰个为true的,就进行语句体n+1

 *

 * if语句的两种格式:

 *      第一种格式适合做一种情景的剖断

 *      第三种格式适合做三种景况的论断

 *      第二种格式适合做各个情景的推断

 */

public class IfDemo3 {

    public static void main(String[] args) {

        // x和y的关系满足如下:

        // x>=3 y = 2x + 1;

        // -1<=x<3 y = 2x;

        // x<=-1 y = 2x – 1;

        // 依照给定的x的值,计算出y的值并出口。

 

        // 定义变量

        int x = 5;

       

        /*

        int y;

        if (x >= 3) {

            y = 2 * x + 1;

        } else if (x >= -1 && x < 3) {

            y = 2 * x;

        } else if (x <= -1) {

            y = 2 * x – 1;

        }else {

            y = 0;

        }

        */

       

        int y = 0;

        if (x >= 3) {

            y = 2 * x + 1;

        } else if (x >= -1 && x < 3) {

            y = 2 * x;

        } else if (x <= -1) {

            y = 2 * x – 1;

        }

       

        System.out.println(“y的值是:”+y);

    }

}

 

2.1.8 算数运算符++和- – 的用法

++,–运算符:对变量做加1或然减1的操作。

++或然–既能放在变量的前面,也足以献身变量的前边。

独立使用的时候,++大概–无论是放在变量的先头还是背后,结果是一律的。

介入操作的时候:

            
如若++恐怕–在变量的背后,先拿变量加入操作,后变量做++只怕–

             
就算++大概–在变量的前方,先变量做++只怕–,后拿变量参与操作

2.1.4 算数运算符取余和除法的分别

 %:取余运算符。得到的是多个相除数据的余数。

 /:除法运算符。获得是八个相除数据的商。

 使用情况: %:判定四个数据是不是整除。

2.1.4 算数运算符取余和除法的差距

%:取余运算符。获得的是三个相除数据的余数。

/:除法运算符。得到是多个相除数据的商。

行使意况: %:决断三个数据是还是不是整除。

1.3      If语句的操练

2.1.9 代码案例六

public class OperatorDemo4 {

    public static void main(String[] args) {

        int a = 10;

        System.out.println(“a:” + a);

 

        // 单独行使

        // a++;

        // ++a;

        // System.out.println(“a:” + a);

 

        // 参加操作使用

        // int b = a++;

        int b = ++a;

        System.out.println(“a:” + a);

        System.out.println(“b:” + b);

    }

}

 

2.1.5 代码案例四

public class OperatorDemo2 {

    public static void main(String[] args) {

        int a = 5;

        int b = 3;

 

        System.out.println(a / b);

        System.out.println(a % b);

    }

}

 

2.1.5 代码案例四

public class OperatorDemo2 {

public static void main(String[] args) {

int a = 5;

int b = 3;

System.out.println;

System.out.println;

}

}

1.3.1      if语句完结获取七个数据非常的大值

2.2  赋值运算符

2.1.6 字符和字符串参预加法操作

字符参加运算

实际是拿该字符对应的数值来操作

‘a’     97

‘A’     65

‘0’     48

字符串出席运算

这里实在做的不是加法运算,而是字符串拼接。

字符串和任何品类的数码做拼接,结果是字符串类型的。

2.1.6 字符和字符串插足加法操作

字符加入运算

实则是拿该字符对应的数值来操作

‘a’ 97

‘A’ 65

‘0’ 48

字符串参预运算

这里其实做的不是加法运算,而是字符串拼接。

字符串和其他品类的数码做拼接,结果是字符串类型的。

1.3.2      代码案例五

package com.itheima_02;

 

import java.util.Scanner;

 

/*

 * 键盘录入三个数据,获取那五个数据的一点都不小值

 *

 * 分析:

 *      A:看到键盘录入,大家就相应想到键盘录入的三手续

 *          导包,创造对象,接收数据

 *     
B:获取这两个数据的不小值,其实便是决断五个数据哪个人大,把大的输出就足以了。

 *

 * 导包:

 *      A:手动导包

 *          import java.util.Scanner;

 *      B:鼠标点击法国红叉叉,自动生成

 *      C:快捷键(推荐)

 *          ctrl+shift+o

 */

public class IfTest {

    public static void main(String[] args) {

        //创造对象

        Scanner sc =
new Scanner(System.in);

       

        //接收数据

        System.out.println(“请输入第四个数据:”);

        int a = sc.nextInt();

       

        System.out.println(“请输入第1个数据:”);

        int b = sc.nextInt();

       

        //接纳if语句格式2落到实处

        /*

        if(a>b){

            System.out.println(“一点都不小的值是:”+a);

        }else {

            System.out.println(“十分的大的值是:”+b);

        }

        */

       

       
//获得十分大的值之后,作者未必想平昔出口,所以我们定义变量接收这些异常的大的值

        int max;

        if(a>b){

            max = a;

        }else {

            max = b;

        }

        //只怕做其余的操作

        //max += 100;

        System.out.println(“异常的大的值是:”+max);

    }

}

2.2.1 赋值运算符分类

中央的赋值运算符:=

增加的赋值运算符:+=,-=,*=,/=,%=

+=: a+=20;也正是a = (a的数据类型)(a + 20);

2.1.7 代码案例五

package com.itheima_01;

/*

 * 整数的加法。

 * 字符参预加法操作。拿字符在Computer中底层存款和储蓄对应的数据值来参预运算的。

 *      ‘0’     48

 *      ‘a’     97

 *      ‘A’     65

 * 字符串参加加法操作。

 *      这里的+其实不是加法,而是字符串连接符。

 */

public class OperatorDemo3 {

    public static void main(String[] args) {

        // 整数加法

        int a = 10;

        int b = 20;

        System.out.println(a + b);

        System.out.println(“——————“);

 

        // 字符参与加法操作

        char c = ‘0’;

        char c2 = ‘a’;

        System.out.println(a + c);

        System.out.println(a + c2);

        System.out.println(“——————“);

 

        // 字符串加入加法操作

        System.out.println(“hello” + a);

        System.out.println(“hello” + a + b); //
“hello”+10,然后再和b进行拼接

        System.out.println(a + b + “hello”);

    }

}

 

2.1.7 代码案例五

package com.itheima_01;

/*

* 整数的加法。

* 字符参预加法操作。拿字符在微型Computer中底层存款和储蓄对应的数据值来到场运算的。

* ‘0’ 48

* ‘a’ 97

* ‘A’ 65

* 字符串到场加法操作。

* 这里的+其实不是加法,而是字符串连接符。

*/

public class OperatorDemo3 {

public static void main(String[] args) {

// 整数加法

int a = 10;

int b = 20;

System.out.println;

System.out.println(“——————“);

// 字符参与加法操作

char c = ‘0’;

char c2 = ‘a’;

System.out.println;

System.out.println;

System.out.println(“——————“);

// 字符串参预加法操作

System.out.println(“hello” + a);

System.out.println(“hello” + a + b); //
“hello”+10,然后再和b实行拼接

System.out.println(a + b + “hello”);

}

}

1.3.3      if语句达成推断学生阶段

2.2.2 代码案例七

package com.itheima_02;

/*

 * 赋值运算符:

 *      A:基本   =

 *      B:扩展   +=,-=,*=,…

 *

 * +=:

 *      a+=20;

 *      相当于

 *      a = (a的数据类型)(a + 20);

 */

public class OperatorDemo {

    public static void main(String[] args) {

        // 把10赋值给int类型的变量a

        int a = 10;

 

        // +=
把左手和右臂的数目开展览演出算,最后赋值给左边。左侧的只可以是变量

        a += 10;// 相当于a = a + 10

        System.out.println(“a:” + a);

        System.out.println(“———————-“);

 

        short s = 10;

        // s += 20; // 相当于 s = s + 20;

        s = (short) (s + 20);

        System.out.println(“s:” + s);

    }

}

 

2.1.8 算数运算符++和- – 的用法

++,–运算符:对变量做加1只怕减1的操作。

++也许–不只能够献身变量的后面,也足以放在变量的日前。

独自采用的时候,++恐怕–无论是放在变量的先头照旧背后,结果是完全一样的。

出席操作的时候:

            
如若++恐怕–在变量的前边,先拿变量参加操作,后变量做++恐怕–

             
假如++恐怕–在变量的前方,先变量做++也许–,后拿变量加入操作

2.1.8 算数运算符++和- – 的用法

++,–运算符:对变量做加1也许减1的操作。

++恐怕–不只能够放在变量的前面,也足以放在变量的后面。

独自使用的时候,++或然–无论是放在变量的先头依旧背后,结果是一模一样的。

插足操作的时候:

即使++恐怕–在变量的后边,先拿变量参预操作,后变量做++恐怕–

假设++可能–在变量的前头,先变量做++只怕–,后拿变量参预操作

1.3.4      代码案例六

package com.itheima_02;

 

import java.util.Scanner;

 

/*

 * 键盘录入学生考试战绩,请依据战表剖断该学生属于哪个品级

 * 90-100   优秀

 * 80-90    好

 * 70-80    良

 * 60-70    及格

 * 60以下   不及格

 *

 * 分析:

 *      A:键盘录入学生考试成绩

 *          三步骤

 *      B:通过轻便的分析,大家决定选择if语句格式3来贯彻

 *

 * 程序一定要思考周详了。

 *      安全部据

 *      边界数据

 *      错误数据

 */

public class IfTest2 {

    public static void main(String[] args) {

        //创设对象

        Scanner sc =
new Scanner(System.in);

       

        //接收数据

        System.out.println(“请输入学生的考试战表:”);

        int score = sc.nextInt();

       

        //if语句格式3

        /*

        if(score>=90 && score<=100){

            System.out.println(“你的实际业绩属于优秀”);

        }else if(score>=80 && score<90){

            System.out.println(“你的战表属于好”);

        }else if(score>=70 && score<80){

            System.out.println(“你的大成属于良”);

        }else if(score>=60 && score<70){

            System.out.println(“你的成就属于合格”);

        }else {

            System.out.println(“你的实际业绩属于不如格”);

        }

        */

       

        //我们开采前后相继相当不足健全,参加错误数据的决断

        if(score<0 || score>100){

            System.out.println(“你的战表是错误的”);

        }else if(score>=90 && score<=100){

            System.out.println(“你的大成属于卓越”);

        }else if(score>=80 && score<90){

            System.out.println(“你的实际业绩属于好”);

        }else if(score>=70 && score<80){

            System.out.println(“你的成绩属于良”);

        }else if(score>=60 && score<70){

            System.out.println(“你的成就属于合格”);

        }else {

            System.out.println(“你的实绩属于不如格”);

        }

    }

}

 

2.3  关系运算符

2.1.9 代码案例六

public class OperatorDemo4 {

    public static void main(String[] args) {

        int a = 10;

        System.out.println(“a:” + a);

 

        // 单独选用

        // a++;

        // ++a;

        // System.out.println(“a:” + a);

 

        // 参预操作使用

        // int b = a++;

        int b = ++a;

        System.out.println(“a:” + a);

        System.out.println(“b:” + b);

    }

}

 

2.1.9 代码案例六

public class OperatorDemo4 {

public static void main(String[] args) {

int a = 10;

System.out.println;

// 单独行使

// a++;

// ++a;

// System.out.println;

// 参加操作使用

// int b = a++;

int b = ++a;

System.out.println;

System.out.println;

}

}

1.4  switch语句的格式及实践流程

2.3.1      基本接纳及注意事项

关系运算符富含以下内容:

==,!=,>,>=,<,<=

提到运算符的结果都以boolean型,也正是依然是true,要么是false。

注意事项:

关系运算符“==”不能够误写成“=”。

2.2  赋值运算符

2.2 赋值运算符

1.4.1 格式解释:

switch代表那是switch语句

表明式的取值:byte,short,int,char

JDK5现在能够是枚举

JDK7现在能够是String

case前边跟的是要和表明式进行相比的值

语句体部分能够是一条或多条语句

break代表暂停,结束的情致,能够甘休switch语句

default语句表示全体情形都不匹配的时候,就进行该处的剧情,和if语句的else相似。

2.3.2      代码案例八

package com.itheima_03;

 

/*

 * 关系运算符:

 *      ==,!=,>,>=,<,<=

 *      关系运算符的结果是boolean类型。

 *

 * 注意:

 *      千万不要把==写成=

 */

public class OperatorDemo {

    public static void main(String[] args) {

        int a = 10;

        int b = 20;

        int c = 10;

 

        System.out.println(a == b);

        System.out.println(a == c);

        System.out.println(“—————–“);

        System.out.println(a != b);

        System.out.println(a != c);

        System.out.println(“—————–“);

        System.out.println(a > b);

        System.out.println(a > c);

        System.out.println(“—————–“);

        System.out.println(a >= b);

        System.out.println(a >= c);

        System.out.println(“—————–“);

 

        int x = 3;

        int y = 4;

        // System.out.println(x == y);

        // System.out.println(x = y);// 把y赋值给x,把x的值输出

        boolean bb = (x == y);

        // 报错

        // boolean cc = (x = y);

        int cc = (x = y);

    }

}

 

2.2.1 赋值运算符分类

焦点的赋值运算符:=

扩张的赋值运算符:+=,-=,*=,/=,%=

+=: a+=20;相当于a = (a的数据类型)(a + 20);

2.2.1 赋值运算符分类

主干的赋值运算符:=

扩大的赋值运算符:+=,-=,*=,/=,%=

+=: a+=20;相当于a = ;

1.4.2 奉行流程

先是总计出表明式的值

说不上,和case依次相比较,一旦有相应的值,就能进行相应的口舌,在执行的历程中,遭受break就能终止。

终极,假设全数的case都和表达式的值不配合,就能够实行default语句体部分,然后程序结束掉。

2.4  逻辑运算符

2.2.2 代码案例七

package com.itheima_02;

/*

 * 赋值运算符:

 *      A:基本   =

 *      B:扩展   +=,-=,*=,…

 *

 * +=:

 *      a+=20;

 *      相当于

 *      a = (a的数据类型)(a + 20);

 */

public class OperatorDemo {

    public static void main(String[] args) {

        // 把10赋值给int类型的变量a

        int a = 10;

 

        // +=
把左手和左边的多寡进行演算,最后赋值给侧边。左侧的只好是变量

        a += 10;// 相当于a = a + 10

        System.out.println(“a:” + a);

        System.out.println(“———————-“);

 

        short s = 10;

        // s += 20; // 相当于 s = s + 20;

        s = (short) (s + 20);

        System.out.println(“s:” + s);

    }

}

 

2.2.2 代码案例七

package com.itheima_02;

/*

* 赋值运算符:

* A:基本 =

* B:扩展 +=,-=,*=,…

*

* +=:

* a+=20;

* 相当于

* a = ;

*/

public class OperatorDemo {

public static void main(String[] args) {

// 把10赋值给int类型的变量a

int a = 10;

// += 把左臂和右侧的数量进行演算,最终赋值给左侧。侧边包车型大巴只可以是变量

a += 10;// 相当于a = a + 10

System.out.println;

System.out.println(“———————-“);

short s = 10;

// s += 20; // 相当于 s = s + 20;

s = (short) ;

System.out.println;

}

}

1.4.3 switch语句推行流程图

 

2.4.1      逻辑运算符概述

A:逻辑运算符有哪些

       &,|,^,!

       &&,||

 B:案例演示

 逻辑运算符的主干用法

      

 C:注意事项:

       a:逻辑运算符一般用于连接boolean类型的表达式也许值。

      
b:表达式:正是用运算符把常量只怕变量连接起来的适合java语法的姿态。

             算术表明式:a + b

              相比较表明式:a == b(条件表明式)

 D:结论:

      &逻辑与:有false则false。

      |逻辑或:有true则true。

      ^逻辑异或:同样为false,差异为true。

      !逻辑非:非false则true,非true则false。

       特点:偶数个不退换本身。

2.3  关系运算符

2.3 关系运算符

1.5  switch语句的练习

2.4.2      代码案例九

package com.itheima_04;

/*

 * 逻辑运算符:用于连接关系表明式。

 * &,|,^,!

 * &&,||

 *

 * 与:& 有false则false

 * 或:| 有true则true

 * 异或:^ 一样则false,分歧则true。(男女盆友)

 * 非:! true则false,false则true

 */

public class OperatorDemo {

    public static void main(String[] args) {

        int a = 10;

        int b = 20;

        int c = 30;

 

        System.out.println((a > b) & (a > c));// false &
false

        System.out.println((a < b) & (a > c)); // true &
false

        System.out.println((a > b) & (a < c)); // false &
true

        System.out.println((a < b) & (a < c)); // true &
true

        System.out.println(“—————“);

        System.out.println((a > b) | (a > c));// false |
false

        System.out.println((a < b) | (a > c)); // true |
false

        System.out.println((a > b) | (a < c)); // false |
true

        System.out.println((a < b) | (a < c)); // true |
true

        System.out.println(“—————“);

        System.out.println((a > b) ^ (a > c));// false ^
false

        System.out.println((a < b) ^ (a > c)); // true ^
false

        System.out.println((a > b) ^ (a < c)); // false ^
true

        System.out.println((a < b) ^ (a < c)); // true ^
true

        System.out.println(“—————“);

        System.out.println((a > b)); // false

        System.out.println(!(a > b)); // !false

        System.out.println(!!(a > b)); // !!false

    }

}

2.3.1      基本选拔及注意事项

提到运算符包罗以下内容:

==,!=,>,>=,<,<=

论及运算符的结果都以boolean型,也便是依旧是true,要么是false。

注意事项:

涉嫌运算符“==”无法误写成“=”。

2.3.1 基本选取及注意事项

关联运算符满含以下内容:

==,!=,>,>=,<,<=

波及运算符的结果都以boolean型,也正是还是是true,要么是false。

注意事项:

涉及运算符“==”不能误写成“=”。

1.5.1 switch语句实现基于数字输出对应星期

2.4.3      逻辑运算符&&与&的分别

A:&&和&的区别?

       a:最后结果同样。

       b:&&具有短路效果。侧边是false,左侧不实行。

       &是无论左侧是false依旧true,侧面都会施行

B:||和|的区别?

       a:最后结出一律

       b:||具备短路效果.侧边是true,左侧不实施

       |是无论左侧是false依旧true,左侧都会进行

2.3.2      代码案例八

package com.itheima_03;

 

/*

 * 关系运算符:

 *      ==,!=,>,>=,<,<=

 *      关系运算符的结果是boolean类型。

 *

 * 注意:

 *      千万不要把==写成=

 */

public class OperatorDemo {

    public static void main(String[] args) {

        int a = 10;

        int b = 20;

        int c = 10;

 

        System.out.println(a == b);

        System.out.println(a == c);

        System.out.println(“—————–“);

        System.out.println(a != b);

        System.out.println(a != c);

        System.out.println(“—————–“);

        System.out.println(a > b);

        System.out.println(a > c);

        System.out.println(“—————–“);

        System.out.println(a >= b);

        System.out.println(a >= c);

        System.out.println(“—————–“);

 

        int x = 3;

        int y = 4;

        // System.out.println(x == y);

        // System.out.println(x = y);// 把y赋值给x,把x的值输出

        boolean bb = (x == y);

        // 报错

        // boolean cc = (x = y);

        int cc = (x = y);

    }

}

 

2.3.2 代码案例八

package com.itheima_03;

/*

* 关系运算符:

* ==,!=,>,>=,<,<=

* 关系运算符的结果是boolean类型。

*

* 注意:

* 千万不要把==写成=

*/

public class OperatorDemo {

public static void main(String[] args) {

int a = 10;

int b = 20;

int c = 10;

System.out.println;

System.澳门葡京备用网址,out.println;

System.out.println(“—————–“);

System.out.println;

System.out.println;

System.out.println(“—————–“);

System.out.println;

System.out.println;

System.out.println(“—————–“);

System.out.println(a >= b);

System.out.println(a >= c);

System.out.println(“—————–“);

int x = 3;

int y = 4;

// System.out.println;

// System.out.println;// 把y赋值给x,把x的值输出

boolean bb = ;

// 报错

// boolean cc = ;

int cc = ;

}

}

1.5.2 代码案例七

package com.itheima_03;

 

import java.util.Scanner;

 

/*

 * switch语句格式:

 * switch(表达式) {

 *      case 值1:

 *          语句体1;

 *          break;

 *      case 值2:

 *          语句体2;

 *          break;

 *      …

 *      default:

 *          语句体n+1;

 *          break;

 * }

 * 格式解释:

 *      表达式:byte,short,int,char

 *          JDK5现在可以是枚举

 *          JDK7今后能够是字符串

 *      case:就是要和表明式进行相比较的值

 *      break:表示暂停,停止的意思。

 *     
default:表示具有的景观都不匹配的时候,就执行语句体n+1。和if语句的else相似。

 * 实施流程:

 *      A:总结出表明式的值

 *     
B:拿总结出来的值和case前边的值依次相比,一旦有关照的值,就试行该处的说话,在实践进度中,蒙受break,就得了。

 *      C:假使具有的case都不匹配,就能够进行default调整的言辞,然后截止。

 * 需求:

 *     
依照键盘录入的数值1,2,3,…7输出对应的周一,周一,星期四…星期天。

 */

public class SwitchDemo {

    public static void main(String[] args) {

        //成立键盘录入对象

        Scanner sc =
new Scanner(System.in);

       

        //接收数据

        System.out.println(“请输入二个数字(1-7):”);

        int weekday = sc.nextInt();

       

        //switch语句实现选取

        switch(weekday) {

        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;

        }

    }

}

 

2.4.4      代码案例十:

package com.itheima_04;

 

/*

 * &&和&的结果一律

 * ||和|的结果同样

 *

 * &&和&的区别:

 *      &&假如左边是false,侧面不实行。

 *      &无论左侧是true还是false,左侧都会实施。

 */

public class OperatorDemo2 {

    public static void main(String[] args) {

        int a = 10;

        int b = 20;

        int c = 30;

 

        System.out.println((a > b) && (a > c));// false &&
false

        System.out.println((a < b) && (a > c)); // true &&
false

        System.out.println((a > b) && (a < c)); // false &&
true

        System.out.println((a < b) && (a < c)); // true &&
true

        System.out.println(“—————“);

        System.out.println((a > b) || (a > c));// false ||
false

        System.out.println((a < b) || (a > c)); // true ||
false

        System.out.println((a > b) || (a < c)); // false ||
true

        System.out.println((a < b) || (a < c)); // true ||
true

        System.out.println(“—————“);

 

        int x = 3;

        int y = 4;

        // System.out.println((x++ > 4) & (y++ > 5)); // false &
false

        System.out.println((x++ > 4) && (y++ > 5)); // false
&& false

        System.out.println(“x:” + x);

        System.out.println(“y:” + y);

    }

}

2.4  逻辑运算符

2.4 逻辑运算符

第2章   循环流程序调控制语句

2.5  安慕希运算符

2.4.1      逻辑运算符概述

A:逻辑运算符有哪些

       &,|,^,!

       &&,||

 B:案例演示

 逻辑运算符的宗旨用法

      

 C:注意事项:

       a:逻辑运算符一般用来连接boolean类型的表达式只怕值。

      
b:表明式:便是用运算符把常量或许变量连接起来的适合java语法的架势。

             算术表明式:a + b

              比较表达式:a == b(条件表明式)

 D:结论:

      &逻辑与:有false则false。

      |逻辑或:有true则true。

      ^逻辑异或:同样为false,分歧为true。

      !逻辑非:非false则true,非true则false。

       特点:偶数个不改造本身。

2.4.1 逻辑运算符概述

A:逻辑运算符有哪些

&,|,^,!

&&,||

B:案例演示

逻辑运算符的焦点用法

C:注意事项:

a:逻辑运算符一般用于连接boolean类型的表明式也许值。

b:表明式:正是用运算符把常量可能变量连接起来的符合java语法的姿态。

算术表明式:a + b

比较表明式:a == b

D:结论:

&逻辑与:有false则false。

|逻辑或:有true则true。

^逻辑异或:一样为false,差别为true。

!逻辑非:非false则true,非true则false。

特点:偶数个不退换自己。

2.1  for循环的格式及大旨使用

2.5.1 长富运算符概述

A:格式

       (关系表达式)?表达式1:表明式2;

       若是条件为true,运算后的结果是表达式1;

       假设条件为false,运算后的结果是公布式2;

B:示例:

       获取四个数中山大学数。

       int x=3,y=4,z;

       z = (x>y)?x:y;//z变量存款和储蓄的正是五个数的造化

2.4.2      代码案例九

package com.itheima_04;

/*

 * 逻辑运算符:用于连接关系表明式。

 * &,|,^,!

 * &&,||

 *

 * 与:& 有false则false

 * 或:| 有true则true

 * 异或:^ 一样则false,分化则true。(男女票)

 * 非:! true则false,false则true

 */

public class OperatorDemo {

    public static void main(String[] args) {

        int a = 10;

        int b = 20;

        int c = 30;

 

        System.out.println((a > b) & (a > c));// false &
false

        System.out.println((a < b) & (a > c)); // true &
false

        System.out.println((a > b) & (a < c)); // false &
true

        System.out.println((a < b) & (a < c)); // true &
true

        System.out.println(“—————“);

        System.out.println((a > b) | (a > c));// false |
false

        System.out.println((a < b) | (a > c)); // true |
false

        System.out.println((a > b) | (a < c)); // false |
true

        System.out.println((a < b) | (a < c)); // true |
true

        System.out.println(“—————“);

        System.out.println((a > b) ^ (a > c));// false ^
false

        System.out.println((a < b) ^ (a > c)); // true ^
false

        System.out.println((a > b) ^ (a < c)); // false ^
true

        System.out.println((a < b) ^ (a < c)); // true ^
true

        System.out.println(“—————“);

        System.out.println((a > b)); // false

        System.out.println(!(a > b)); // !false

        System.out.println(!!(a > b)); // !!false

    }

}

2.4.2 代码案例九

package com.itheima_04;

/*

* 逻辑运算符:用于连接关系表明式。

* &,|,^,!

* &&,||

*

* 与:& 有false则false

* 或:| 有true则true

* 异或:^ 相同则false,不同则true。

* 非:! true则false,false则true

*/

public class OperatorDemo {

public static void main(String[] args) {

int a = 10;

int b = 20;

int c = 30;

System.out.println( & );// false & false

System.out.println( & ); // true & false

System.out.println( & ); // false & true

System.out.println( & ); // true & true

System.out.println(“—————“);

System.out.println( | );// false | false

System.out.println( | ); // true | false

System.out.println( | ); // false | true

System.out.println( | ); // true | true

System.out.println(“—————“);

System.out.println( ^ );// false ^ false

System.out.println( ^ ); // true ^ false

System.out.println( ^ ); // false ^ true

System.out.println( ^ ); // true ^ true

System.out.println(“—————“);

System.out.println(); // false

System.out.println(!); // !false

System.out.println(!!); // !!false

}

}

2.1.1 for循环语句格式:

for(初叶化语句;判别规范语句;调节标准语句) {

         循环体语句;

    }

2.5.2 代码案例十一

package com.itheima_05;

/*

 * 安慕希运算符:

 *

 * 格式:

 *      (关系表明式)?表明式1:表明式2;

 * 推行流程:

 *      A:总计关系表明式的值,看是true依旧false

 *      B:假使是true,表明式1正是运算结果

 *            假如是false,表达式2正是运算结果

 */

public class OperatorDemo {

    public static void main(String[] args) {

        int a = 10;

        int b = 20;

 

        int c = (a > b) ? a : b;

        System.out.println(“c:” + c);

    }

}

 

2.4.3      逻辑运算符&&与&的分化

A:&&和&的区别?

       a:最后结出一律。

       b:&&具备短路效果。侧边是false,右侧不实践。

       &是不管侧边是false照旧true,左侧都会实践

B:||和|的区别?

       a:最后结果一律

       b:||具备短路效果.左侧是true,左边不实践

       |是不管左边是false依然true,左侧都会施行

2.4.3 逻辑运算符&&与&的差距

A:&&和&的区别?

a:最后结出相同。

b:&&具有短路效果。侧边是false,左侧不施行。

&是随便左侧是false照旧true,左边都会实践

B:||和|的区别?

a:最终结出一致

b:||具备短路效果.侧边是true,侧面不推行

|是不管侧边是false还是true,侧边都会推行

2.1.2 施行流程

A:施行开首化语句

B:实行度量准则语句,看其结果是true依然false

假即使false,循环甘休。

倘假如true,继续试行。

C:实行循环体语句

D:实践调整原则语句

E:回到B继续

2.5.3 代码案例十二(相比多少个数是或不是一致)

package com.itheima_05;

 

/* 

 * 长富运算符的演练

 * 比非常多少个整数是或不是一致

 */

public class OperatorTest {

    public static void main(String[] args) {

        // 定义多个int类型的变量

        int a = 10;

        int b = 20;

 

        boolean flag = (a == b) ? true : false;

        // boolean flag = (a == b);

        System.out.println(flag);

    }

}

 

2.4.4      代码案例十:

package com.itheima_04;

 

/*

 * &&和&的结果一律

 * ||和|的结果同样

 *

 * &&和&的区别:

 *      &&假诺左边是false,右侧不试行。

 *      &无论左边是true依然false,侧边都会施行。

 */

public class OperatorDemo2 {

    public static void main(String[] args) {

        int a = 10;

        int b = 20;

        int c = 30;

 

        System.out.println((a > b) && (a > c));// false &&
false

        System.out.println((a < b) && (a > c)); // true &&
false

        System.out.println((a > b) && (a < c)); // false &&
true

        System.out.println((a < b) && (a < c)); // true &&
true

        System.out.println(“—————“);

        System.out.println((a > b) || (a > c));// false ||
false

        System.out.println((a < b) || (a > c)); // true ||
false

        System.out.println((a > b) || (a < c)); // false ||
true

        System.out.println((a < b) || (a < c)); // true ||
true

        System.out.println(“—————“);

 

        int x = 3;

        int y = 4;

        // System.out.println((x++ > 4) & (y++ > 5)); // false &
false

        System.out.println((x++ > 4) && (y++ > 5)); // false
&& false

        System.out.println(“x:” + x);

        System.out.println(“y:” + y);

    }

}

2.4.4 代码案例十:

package com.itheima_04;

/*

* &&和&的结果一律

* ||和|的结果一样

*

* &&和&的区别:

* &&假若左侧是false,左边不试行。

* &无论左侧是true依然false,侧面都会推行。

*/

public class OperatorDemo2 {

public static void main(String[] args) {

int a = 10;

int b = 20;

int c = 30;

System.out.println( && );// false && false

System.out.println( && ); // true && false

System.out.println( && ); // false && true

System.out.println( && ); // true && true

System.out.println(“—————“);

System.out.println( || );// false || false

System.out.println( || ); // true || false

System.out.println( || ); // false || true

System.out.println( || ); // true || true

System.out.println(“—————“);

int x = 3;

int y = 4;

// System.out.println((x++ > 4) & (y++ > 5)); // false & false

System.out.println((x++ > 4) && (y++ > 5)); // false &&
false

System.out.println;

System.out.println;

}

}

2.1.3 for循环的实践流程图

 

2.5.4 代码案例十三(获取四个数中的最大值)

package com.itheima_05;

/*

 * 获取多个整数中的最大值

 */

public class OperatorTest2 {

    public static void main(String[] args) {

        // 定义八个int类型的变量

        int a = 10;

        int b = 30;

        int c = 20;

 

        // 先比较三个整数的大值

        int temp = ((a > b) ? a : b);

        int max = ((temp > c) ? temp : c);

        System.out.println(“max:” + max);

    }

}

 

2.5  三元运算符

2.5 伊利运算符

2.1.4 代码案例八

package com.itheima_04;

/*

 * for循环语句格式:

 *      for(开头化语句;衡量标准语句;调控规范语句) {

 *          循环体语句;

 *      }

 *

 *      实施流程:

 *          A:执行先导化语句

 *          B:推行推断标准语句,看结果是true依然false

 *              假设是true,就继续实施

 *              尽管是false,就得了循环

 *          C:实践循环体语句

 *          D:施行调控标准语句

 *          E:回到B继续

 *

 * 需求:

 *      在调整台出口14遍”HelloWorld”的案例。

 */

public class ForDemo {

    public static void main(String[] args) {

        //原始写法

        System.out.println(“HelloWorld”);

        System.out.println(“HelloWorld”);

        System.out.println(“HelloWorld”);

        System.out.println(“HelloWorld”);

        System.out.println(“HelloWorld”);

        System.out.println(“HelloWorld”);

        System.out.println(“HelloWorld”);

        System.out.println(“HelloWorld”);

        System.out.println(“HelloWorld”);

        System.out.println(“HelloWorld”);

        System.out.println(“————————-“);

       

        //用循环改正

        for(int x=1; x<=10; x++) {

            System.out.println(“HelloWorld”);

        }

    }

}

 

第3章   键盘录入

2.5.1 安慕希运算符概述

A:格式

       (关系表达式)?表明式1:表明式2;

       倘若基准为true,运算后的结果是表达式1;

       假诺基准为false,运算后的结果是表述式2;

B:示例:

       获取多少个数中山高校数。

       int x=3,y=4,z;

       z = (x>y)?x:y;//z变量存款和储蓄的便是七个数的运气

2.5.1 安慕希运算符概述

A:格式

?表达式1:表达式2;

一旦条件为true,运算后的结果是表明式1;

只要基准为false,运算后的结果是表述式2;

B:示例:

获得三个数中山高校数。

int x=3,y=4,z;

z = ?x:y;//z变量存款和储蓄的便是七个数的气数

2.2  for循环的演练

3.1  键盘录入的为主步骤

2.5.2 代码案例十一

package com.itheima_05;

/*

 * 莫斯利安运算符:

 *

 * 格式:

 *      (关系表明式)?表明式1:表明式2;

 * 实践流程:

 *      A:计算关系表达式的值,看是true依然false

 *      B:假如是true,表达式1就是运算结果

 *            假诺是false,表达式2就是运算结果

 */

public class OperatorDemo {

    public static void main(String[] args) {

        int a = 10;

        int b = 20;

 

        int c = (a > b) ? a : b;

        System.out.println(“c:” + c);

    }

}

 

2.5.2 代码案例十一

package com.itheima_05;

/*

* 长富运算符:

*

* 格式:

* ?表达式1:表达式2;

* 实行流程:

* A:计算关系表达式的值,看是true照旧false

* B:假如是true,表明式1就是运算结果

* 假若是false,表明式2正是运算结果

*/

public class OperatorDemo {

public static void main(String[] args) {

int a = 10;

int b = 20;

int c = ? a : b;

System.out.println;

}

}

2.2.1 for循环达成获取钦定范围数据

3.1.1      键盘录入数据概述

咱们当下在写程序的时候,数据值都是长久的,可是实际支付中,数据值分明是浮动的,所以,把数量革新为键盘录入,提升程序的油滑。

键盘录入数据的步子:

A:导包(位寄放置class定义的方面)

       import java.util.Scanner;

B:创立对象

       Scanner sc = new Scanner(System.in);

C:接收数据

       int x = sc.nextInt();

2.5.3 代码案例十二(相比三个数是不是一致)

package com.itheima_05;

 

/* 

 * 安慕希运算符的演习

 * 相比很多少个整数是或不是一致

 */

public class OperatorTest {

    public static void main(String[] args) {

        // 定义三个int类型的变量

        int a = 10;

        int b = 20;

 

        boolean flag = (a == b) ? true : false;

        // boolean flag = (a == b);

        System.out.println(flag);

    }

}

 

2.5.3 代码案例十二(比相当多个数是不是一样)

package com.itheima_05;

/*

* 长富运算符的勤学苦练

* 相比七个整数是不是同样

*/

public class OperatorTest {

public static void main(String[] args) {

// 定义四个int类型的变量

int a = 10;

int b = 20;

boolean flag = ? true : false;

// boolean flag = ;

System.out.println;

}

}

2.2.2 代码案例九

package com.itheima_04;

/*

 * 需要:获取数据1-5和5-1

 */

public class ForTest {

    public static void main(String[] args) {

        //原始做法

        System.out.println(1);

        System.out.println(2);

        System.out.println(3);

        System.out.println(4);

        System.out.println(5);

        System.out.println(“————-“);

       

        //用循环改正

        for(int x=1; x<=5; x++) {

            System.out.println(x);

        }

        System.out.println(“————-“);

       

        //1-5的数目大家收获到了,怎么样收获5-1吧?

        for(int x=5; x>=1; x–){

            System.out.println(x);

        }

    }

}

3.1.2      代码案例十四

package com.itheima;

import java.util.Scanner;

/*

 * 为了升高程序的八面见光,大家就把数据立异为键盘录入。

 * 怎么样落到实处键盘录入呢?最近我们只能采用JDK提供的类Scanner。

 * 这些动用的步子,近些日子大家记住就能够了。

 *

 * 使用手续:

 *      A:导包

 *          import java.util.Scanner;

 *          类中的顺序:package > import > class

 *      B:成立对象

 *          Scanner sc = new Scanner(System.in);

 *      C:接收数据

 *          int i = sc.nextInt();

 */

 

public class ScannerDemo {

    public static void main(String[] args) {

        //创立键盘录入数据的靶子

        Scanner sc = new Scanner(System.in);

       

        //接收数据

        System.out.println(“请录入贰个大背头:”);

        int i = sc.nextInt();

       

        //输出数据

        System.out.println(“i:”+i);

    }

}

2.5.4 代码案例十三(获取八个数中的最大值)

package com.itheima_05;

/*

 * 获取四个整数中的最大值

 */

public class OperatorTest2 {

    public static void main(String[] args) {

        // 定义三个int类型的变量

        int a = 10;

        int b = 30;

        int c = 20;

 

        // 先比较七个整数的大值

        int temp = ((a > b) ? a : b);

        int max = ((temp > c) ? temp : c);

        System.out.println(“max:” + max);

    }

}

 

2.5.4 代码案例十三(获取多个数中的最大值)

package com.itheima_05;

/*

* 获取多少个整数中的最大值

*/

public class OperatorTest2 {

public static void main(String[] args) {

// 定义多个int类型的变量

int a = 10;

int b = 30;

int c = 20;

// 先相比较八个整数的大值

int temp = ( ? a : b);

int max = ((temp > c) ? temp : c);

System.out.println(“max:” + max);

}

}

2.2.3 for循环完成1-5以内数据求和

3.2  键盘录入的演练

第3章   键盘录入

第3章 键盘录入

2.2.4 代码案例十

package com.itheima_04;

/*

 * 须要:求出1-5时期数据之和

 *

 * 分析:

 *      A:定义求和变量,早先化值是0

 *      B:获取1-5里面包车型客车数量,用for循环完成

 *      C:把每一回获得到的数额,累加起来就足以了

 *      D:输出求和变量就能够

 */

public class ForTest2 {

    public static void main(String[] args) {

        //定义求和变量,伊始化值是0

        int sum = 0;

       

        //获取1-5时期的多少,用for循环达成

        for(int x=1; x<=5; x++) {

            //把每一趟拿到到的数目,累加起来就足以了

            //sum = sum + x;

            /*

             * 第一次:sum = 0 + 1 = 1

             * 第二次:sum = 1 + 2 = 3

             * 第三次:sum = 3 + 3 = 6

             * 第四次:sum = 6 + 4 = 10

             * 第五次:sum = 10 + 5 = 15

             */

            sum += x;

        }

       

        //输出求和结果

        System.out.println(“sum:”+sum);

    }

}

 

3.2.1      键盘录入四个数据并求和

  键盘录入多个数据,并对那五个数据求和,输出其结果

 键盘录入:

             A:导包

             B:创立对象

             C:接收数据

3.1  键盘录入的中央步骤

3.1 键盘录入的主干步骤

2.2.5 for循环达成1-100中间偶数和

3.2.2      代码案例十五

package com.itheima;

 

import java.util.Scanner;

public class ScannerTest {

    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();

 

        // 对数码实行求和

        int sum = a + b;

        System.out.println(“sum:” + sum);

    }

}

 

3.1.1      键盘录入数据概述

我们当前在写程序的时候,数据值都以原则性的,不过实际上开支中,数据值肯定是浮动的,所以,把数据革新为键盘录入,提升程序的油滑。

键盘录入数据的手续:

A:导包(位贮存置class定义的地点)

       import java.util.Scanner;

B:创设对象

       Scanner sc = new Scanner(System.in);

C:接收数据

       int x = sc.nextInt();

3.1.1 键盘录入数据概述

大家脚下在写程序的时候,数据值都是定点的,不过事实上支出中,数据值肯定是生成的,所以,把多少立异为键盘录入,升高程序的灵活性。

键盘录入数据的步骤:

A:导包(位寄放置class定义的上面)

import java.util.Scanner;

B:成立对象

Scanner sc = new Scanner(System.in);

C:接收数据

int x = sc.nextInt();

2.2.6 代码案例十一

package com.itheima_04;

/*

 * 要求:求出1-100里面偶数和

 *

 * 分析:

 *      A:定义求和变量,初阶化值是0

 *      B:获取1-100之间的数码,用for循环完毕

 *      C:把收获到的多寡开展剖断,看是不是是偶数

 *          如果是,就累加

 *      D:输出求和结果

 */

public class ForTest3 {

    public static void main(String[] args) {

        //定义求和变量,开端化值是0

        int sum = 0;

       

        //获取1-100里面包车型大巴数据,用for循环完毕

        for(int x=1; x<=100; x++) {

            //把获取到的数码举行判定,看是还是不是是偶数

            if(x%2 ==0) {

                sum += x;

            }

        }

       

        //输出求和结果

        System.out.println(“sum:”+sum);

    }

}

 

 

3.2.3      键盘录入三个数据相比较是不是等于

键盘录入八个数据,相比那多少个数据是或不是等于

3.1.2      代码案例十四

package com.itheima;

import java.util.Scanner;

/*

 * 为了加强程序的灵活性,大家就把数据立异为键盘录入。

 * 怎么样兑现键盘录入呢?方今大家只可以选取JDK提供的类Scanner。

 * 那几个应用的步调,前段时间我们记住就能够了。

 *

 * 使用手续:

 *      A:导包

 *          import java.util.Scanner;

 *          类中的顺序:package > import > class

 *      B:创设对象

 *          Scanner sc
= new Scanner(System.in);

 *      C:接收数据

 *          int i =
sc.nextInt();

 */

 

public class ScannerDemo {

    public static void main(String[] args) {

        //创立键盘录入数据的靶子

        Scanner sc =
new Scanner(System.in);

       

        //接收数据

        System.out.println(“请录入八个整数:”);

        int i = sc.nextInt();

       

        //输出数据

        System.out.println(“i:”+i);

    }

}

3.1.2 代码案例十四

package com.itheima;

import java.util.Scanner;

/*

* 为了增进程序的八面玲珑,大家就把数据革新为键盘录入。

* 如何兑现键盘录入呢?近日大家不得不利用JDK提供的类Scanner。

* 那几个动用的步子,近来我们记住就足以了。

*

* 使用手续:

* A:导包

* importjava.util.Scanner;

* 类中的顺序:package> import > class

* B:创立对象

* Scannersc = new
Scanner(System.in);

* C:接收数据

* inti = sc.nextInt();

*/

public class ScannerDemo {

public staticvoid main(String[] args) {

//创制键盘录入数据的目的

Scannersc =
newScanner(System.in);

//接收数据

System.out.println(“请录入贰个大背头:”);

int i = sc.nextInt();

//输出数据

System.out.println;

}

}

2.2.7 for循环达成在调节台打字与印刷金盏银台数

3.2.4      代码案例十六

package com.itheima;

import java.util.Scanner;

 

/*

 * 键盘录入七个数据,相比那四个数据是不是等于

 */

public class ScannerTest2 {

    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 flag = ((a == b) ? true : false);

        boolean flag = (a == b);

        System.out.println(“flag:” + flag);

    }

}

 

3.2  键盘录入的练习

3.2 键盘录入的演练

2.2.8 代码案例十二

package com.itheima_04;

/*

 * 必要:在决定台出口全数的”雅蒜数”

 *

 * 分析:

 *      什么是金盏银台数呢?

 *         
所谓的女史花数是指贰个三个人数,其各位数字的立方和极其该数本人。

 *          比方:153就是四个雅蒜数。

 *          153 = 1*1*1 + 5*5*5 + 3*3*3

 *

 *      A:二个人数实际就报告了作者们姚女子花剑数的限量

 *          100-999

 *      B:怎么着得到二个数码的每种位上的数呢?

 *          譬如:作者有一个数量153,请问怎样得到到个位,拾一位,百位

 *          个位:153%10 = 3;

 *          十位:153/10%10 = 5;

 *          百位:153/10/10%10 = 1;

 *          千位:…

 *          万位:…

 *     
C:让各类位上的立方和相加,并和该数量进行比较,假诺相等,就注明该数额是金盏银台数,在决定台出口

 */

public class ForTest4 {

    public static void main(String[] args) {

        //通过巡回获取到每一个四个人数

        for(int x=100; x<1000; x++) {

            //获取个位,拾位,百位

            int ge = x%10;

            int shi = x/10%10;

            int bai = x/10/10%10;

           

           
//让每一个位上的立方和相加,并和该数量进行相比,要是相等,就印证该数额是雅蒜数,在决定台出口

            if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {

                System.out.println(x);

            }

        }

    }

}

3.2.5      键盘录入八个数据得到最大值

键盘录入八个数据,获取那四个数据中的最大值

3.2.1      键盘录入四个数据并求和

  键盘录入多个数据,并对那多个数据求和,输出其结果

 键盘录入:

             A:导包

             B:创制对象

             C:接收数据

3.2.1 键盘录入五个数据并求和

键盘录入多个数据,并对那多少个数据求和,输出其结果

键盘录入:

A:导包

B:创制对象

C:接收数据

2.2.9 for循环达成总括金盏银台的个数

3.2.6      代码案例十七

package com.itheima;

 

import java.util.Scanner;

 

/*

 * 键盘录入五个数据,获取那几个数据中的最大值

 */

public class ScannerTest3 {

    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 temp = (a > b ? a : b);

        int max = (temp > c ? temp : c);

 

        System.out.println(“max:” + max);

    }

}

 

第02天
java基础知识 今天内容介绍 u Eclipse的安装、配置及运用 u 运算符 u
键盘录入 第1章 Eclipse开垦工具 1….

3.2.2      代码案例十五

package com.itheima;

 

import java.util.Scanner;

public class ScannerTest {

    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();

 

        // 对数据举行求和

        int sum = a + b;

        System.out.println(“sum:” + sum);

    }

}

 

3.2.2 代码案例十五

package com.itheima;

import java.util.Scanner;

public class ScannerTest {

public staticvoid main(String[] args) {

// 成立对象

Scannersc =
newScanner(System.in);

// 接收数据

System.out.println(“请输入第二个数据:”);

int a = sc.nextInt();

System.out.println(“请输入第二个数据:”);

int b = sc.nextInt();

// 对数据进行求和

int sum = a + b;

System.out.println(“sum:”+ sum);

}

}

2.2.10         代码案例十三

package com.itheima_04;

/*

 * 供给:计算”金盏银台数”共有多少个

 *

 * 分析:

 *      A:定义总结变量,开头化值是0

 *      B:获取贰人数,用for循环达成

 *      C:获取二位数的个位,十位,百位

 *      D:决断那几个三个人数是不是是玉玲珑数,假诺是,计算变量++

 *      E:输出总结结果就能够了

 */

public class ForTest5 {

    public static void main(String[] args) {

        //定义总计变量,初步化值是0

        int count = 0;

       

        //获取二人数,用for循环完结

        for(int x=100; x<1000; x++) {

            //获取四人数的个位,十二位,百位

            int ge = x%10;

            int shi = x/10%10;

            int bai = x/10/10%10;

           

            //判定那个四人数是或不是是天葱数,假使是,总计变量++

            if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {

                count++;

            }

        }

       

        //输出总括结果就足以了

        System.out.println(“水仙花数共有:”+count+”个”);

    }

}

 

3.2.3      键盘录入多个数据比较是还是不是等于

键盘录入三个数据,相比那七个数据是还是不是等于

3.2.3 键盘录入四个数据比较是或不是等于

键盘录入多少个数据,相比这多个数据是不是等于

2.3  while循环的格式及骨干选取

3.2.4      代码案例十六

package com.itheima;

import java.util.Scanner;

 

/*

 * 键盘录入七个数据,相比较那三个数据是还是不是等于

 */

public class ScannerTest2 {

    public static void main(String[] args) {

        // 创立对象

        Scanner sc =
new Scanner(System.in);

 

        // 接收数据

        System.out.println(“请输入第二个数据:”);

        int a = sc.nextInt();

 

        System.out.println(“请输入第3个数据:”);

        int b = sc.nextInt();

 

        // 比非常多个数据是或不是等于

        // boolean flag = ((a == b) ? true : false);

        boolean flag = (a == b);

        System.out.println(“flag:” + flag);

    }

}

 

3.2.4 代码案例十六

package com.itheima;

import java.util.Scanner;

/*

* 键盘录入多个数据,相比那三个数据是还是不是等于

*/

public class ScannerTest2 {

public staticvoid main(String[] args) {

// 创设对象

Scannersc =
newScanner(System.in);

// 接收数据

System.out.println(“请输入第二个数据:”);

int a = sc.nextInt();

System.out.println(“请输入第贰个数据:”);

int b = sc.nextInt();

// 相比七个数据是不是等于

// boolean flag = ? true : false);

boolean flag= ;

System.out.println(“flag:”+ flag);

}

}

2.3.1 while循环语句格式

主旨格式

   while(衡量模范语句) {

         循环体语句;

   }

扩展格式

   初阶化语句;

   while(判定标准语句) {

         循环体语句;

         调控标准语句;

}

3.2.5      键盘录入多少个数据获得最大值

键盘录入多少个数据,获取那七个数据中的最大值

3.2.5 键盘录入多少个数据获得最大值

键盘录入几个数据,获取那多少个数据中的最大值

2.3.2 推行流程图

 

3.2.6      代码案例十七

package com.itheima;

 

import java.util.Scanner;

 

/*

 * 键盘录入几个数据,获取这多少个数据中的最大值

 */

public class ScannerTest3 {

    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 temp = (a > b ? a : b);

        int max = (temp > c ? temp : c);

 

        System.out.println(“max:” + max);

    }

}

 

3.2.6 代码案例十七

package com.itheima;

import java.util.Scanner;

/*

* 键盘录入四个数据,获取那多个数据中的最大值

*/

public class ScannerTest3 {

public staticvoid main(String[] args) {

// 创设对象

Scannersc =
newScanner(System.in);

// 接收数据

System.out.println(“请输入第三个数据:”);

int a = sc.nextInt();

System.out.println(“请输入第四个数据:”);

int b = sc.nextInt();

System.out.println(“请输入第多个数据:”);

int c = sc.nextInt();

// 怎么样获得多个数据的最大值

int temp =(a > b? a : b);

int max = (temp > c ? temp : c);

System.out.println(“max:”+ max);

}

}

2.3.3      代码案例十四

package com.itheima_05;

/*

 * while循环语句的着力格式:

 *      while(剖断标准语句) {

 *          循环体语句;

 *      }

 * 扩大格式:

 *      开端化语句;

 *      while(衡量尺度语句) {

 *          循环体语句;

 *          调控规范语句;

 *      }

 *

 * 回看for循环的语句格式:

 *      for(开端化语句;测量尺度语句;调节原则语句) {

 *          循环体语句;

 *      }

 */

public class WhileDemo {

    public static void main(String[] args) {

        //输出10次HelloWorld

        /*

        for(int x=1;
x<=10; x++) {

            System.out.println(“HellloWorld”);

        }

        */

       

        //while循环实现

        int x=1;

        while(x<=10) {

            System.out.println(“HellloWorld”);

            x++;

        }

    }

}

2.4  while循环的练习

2.4.1      while循环完毕1-100中间数据求和

2.4.2      代码案例十五

package com.itheima_05;

/*

 * 求1-100之和。

 * 演习:总结姚女子花剑个数。

 */

public class WhileTest {

    public static void main(String[] args) {

        //回看for循环达成

       

        /*

        //定义求和变量

        int sum = 0;

        //获取1-100里边的数目

        for(int x=1;
x<=100; x++) {

            //累加

            sum += x;

        }

        System.out.println(“1-100的和是:”+sum);

        */

       

        //while循环完结

        //定义求和变量

        int sum = 0;

        int x = 1;

        while(x<=100) {

            sum += x;

            x++;

        }

        System.out.println(“1-100的和是:”+sum);

    }

}

 

2.5  do…while循环的格式及骨干使用

2.5.1 do…while循环语句格式

大旨格式

   do {

         循环体语句;

   }while((推断规范语句);

扩展格式

   开始化语句;

   do {

         循环体语句;

         调控标准语句;

} while((测量准则语句);

2.5.2 试行流程图

 

 

2.5.3 代码案例十六

package com.itheima_06;

/*

 * do…while循环的宗旨格式:

 *      do {

 *          循环体语句;

 *      }while(判定标准语句);

 * 扩大格式:

 *      初叶化语句;

 *      do {

 *          循环体语句;

 *          调整标准语句;

 *      }while(判别标准语句);

 * 试行流程:

 *      A:实行最早化语句;

 *      B:试行循环身体语言句;

 *      C:试行调整原则语句;

 *      D:实行剖断规范语句,看是true依然false

 *          如果是true,回到B继续

 *          如果是false,就结束

 *

 * 练习:

 *      求和案例

 *      总结金盏银台个数

 */

public class DoWhileDemo {

    public static void main(String[] args) {

        //输出10次 HelloWorld

        /*

        for(int x=1;
x<=10; x++) {

            System.out.println(“HelloWorld”);

        }

        */

       

        //do…while改写

        int x=1;

        do {

            System.out.println(“HelloWorld”);

            x++;

        }while(x<=10);

    }

}

2.6  三种循环的分歧

2.6.1 分歧概述

虽说能够成功相同的法力,不过仍旧有小差别:

do…while循环至少会推行一遍循环体。

for循环和while循环唯有在规范化创建的时候才会去实行循环体

for循环语句和while循环语句的小分别:

接纳分别:调控原则语句所决定的相当变量,在for循环停止后,就无法再被访问到了,而while循环甘休还是能承继采用,假让你想继续使用,就用while,不然推荐应用for。原因是for循环甘休,该变量就从内部存款和储蓄器中冲消,可以抓实内部存款和储蓄器的应用功用。

 

2.6.2 代码案例十七

package com.itheima_06;

/*

 * 三种循环的分别:

 *      A:do…while至少实行贰遍循环体

 *      B:for,while循环先判别标准是不是建构,然后决定是不是试行循环体

 *

 * for和while的小分别:

 *     
for循环的初阶化变量,在循环停止后,不得以被访谈。而while循环的初叶化变量,是能够被三回九转使用的。

 *     
假若初阶化变量,前边还要继续访谈,就动用while,不然,推荐应用for。

 *

 * 循环的选取推荐:

 *      for — while — do…while

 */

public class DoWhileDemo2 {

    public static void main(String[] args) {

        /*

        int x = 3;

        while(x<3) {

            System.out.println(“小编爱林青霞(Lin Qingxia)”);

            x++;

        }

        System.out.println(“————–“);

        int y = 3;

        do {

            System.out.println(“作者爱林青霞(Lin Qingxia)”);

            y++;

        }while(y<3);

        */

       

       

        for(int x=1; x<=10; x++){

            System.out.println(“爱生活,爱Java”);

        }

        //这里的x不能够继续探访

        //System.out.println(x);

        System.out.println(“—————–“);

       

        int y = 1;

        while(y<=10) {

            System.out.println(“爱生活,爱Java”);

            y++;

        }

        System.out.println(y);

    }

}

                                                                          

第3章   调整循环语句

3.1  调节跳转语句break

3.1.1      Break的应用处境和功力

break的采纳处境:

在挑选结构switch语句中

在循环语句中

距离使用处境的留存是未曾意义的

break的作用:

跳出单层循环

3.1.2      代码案例十八

package com.itheima_07;

/*

 * break:中断的意思

 * 使用处境:

 *      A:switch语句中

 *      B:循环中

 * 注意:

 *      离开使用情况是从未意思的。

 * 作用:

 *      跳出循环,让循环提前甘休

 */

public class BreakDemo {

    public static void main(String[] args) {

        //break;

       

        for(int x=1; x<=10; x++) {

            if(x == 3) {

                break;

            }

            System.out.println(“HelloWorld”);

        }

    }

}

 

3.2  调整跳转语句continue

3.2.1 continue的利用情况:

在循环语句中

离开使用情形的存在是一向不意思的

continue的作用:

单层循环相比较break,然后总括八个的差别

break  退出当前轮回

continue  退出这次巡回

3.2.2      代码案例十九

package com.itheima_07;

/*

 * continue:继续的情趣

 * 使用景况:

 *      循环中

 * 注意:

 *      离开使用处境是尚未意思的

 * 作用:

 *      停止一次巡回,继续下三回的循环

 * 区别:

 *      break:退出循环

 *      continue:结束二遍巡回,继续下二遍的大循环

 */

public class ContinueDemo {

    public static void main(String[] args) {

        //continue;

       

        for(int x=1; x<=10; x++) {

            if(x == 3) {

                //break;

                continue;

            }

            System.out.println(“HelloWorld”);

        }

    }

}

 

3.3  调整跳转语句演练

3.3.1 练习需要:

按需求分析结果,并证实

       for(int x=1; x<=10; x++) {

              if(x%3==0) {

                     //分别写break,continue,说说出口几回

              }

              System.out.println(“我爱林青霞女士”);

       }

 

3.3.2 代码案例二十

package com.itheima_07;

/*

 * 按要求解析结果,并证实

 *

 * break:输出2次

 * continue:输出7次

 */

public class BreakAndContinueDemo {

    public static void main(String[] args) {

 

        for (int x = 1; x <= 10; x++) {

            if (x % 3 == 0) {

                // 分别写break,continue,说说出口四回

                //break;

                continue;

            }

            System.out.println(“小编爱林青霞女士”);

        }

 

    }

}

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website