快捷搜索:

java语言基础

02.01_Java语言基础(常量的概述和使用)(掌握)

* A:什么是常量

         * 在程序执行的过程中其值不可以发生改变

* B:Java中常量的分类

         * 字面值常量

         * 自定义常量(面向对象部分讲)

* C:字面值常量的分类

         * 字符串常量         用双引号括起来的内容

         * 整数常量              所有整数

         * 小数常量              所有小数

         * 字符常量              用单引号括起来的内容,里面只能放单个数字,单个字母或单个符号

         * 布尔常量              较为特殊,只有true和false

         * 空常量                       null(数组部分讲解)

 

* D:案例演示

         * 用输出语句输出各种常量。null不演示

                           

###02.02_Java语言基础(进制概述和二,八,十六进制图解)(了解)

* A:什么是进制

         * 进制:就是进位制,是人们规定的一种进位方法。 对于任何一种进制--X进制,就表示某一位置上的数运算时是逢X进一位。二进制就是逢二进一,八进制是逢八进一,十进制是逢十进一,十六进制是逢十六进一。

         * 例如一周有七天,七进制,一年有十二个月,十二进制

* B:十进制的由来

         * 十进制的由来是因为人类有十个手指

* C:二进制的由来

         * 其实二进制来源与中国,请看史料记载

         * 18世纪德国数理哲学大师莱布尼兹从他的传教士朋友鲍威特寄给他的拉丁文译本《易经》中,读到了八卦的组成结构,惊奇地发现其基本素数(0)(1),即《易经》的阴爻yao- -和__阳爻,其进位制就是二进制,并认为这是世界上数学进制中最先进的。20世纪被称作第三次科技革命的重要标志之一的计算机的发明与应用,其运算模式正是二进制。它不但证明了莱布尼兹的原理是正确的,同时也证明了《易经》数理学是很了不起的。

* D:八进制的由来

         * 任何数据在计算机中都是以二进制的形式存在的。二进制早期由电信号开关演变而来。一个整数在内存中一样也是二进制的,但是使用一大串的1或者0组成的数值进行使用很麻烦。

         * 所以就想把一大串缩短点,将二进制中的三位用一位表示。这三位可以取到的最大值就是7.超过7就进位了,这就是八进制。

* E:十六进制的由来

         * 但是对于过长的二进制变成八进制还是较长,所以出现的用4个二进制位表示一位的情况,四个二进制位最大是15,这就是十六进制。

* F:不同进制表现同一个数据的形式特点

         * 进制越大,表现形式越短

 

###02.03_Java语言基础(不同进制数据的表现形式)(掌握)

* A:二进制的数据表现形式

         * 由0,1组成。以0b(b可以大写也可以小写)开头(JDK1.7版本可以表示二进制了)

* B:八进制的数据表现形式

         * 由0,1,…7组成。以0开头

* C:十进制的数据表现形式

         * 由0,1,…9组成。整数默认是十进制的

* D:十六进制的数据表现形式

         * 由0,1,…9,a,b,c,d,e,f(大小写均可)。以0x开头

* E:案例演示

         * 输出不同进制表现100的数据。

         * 0b100

         * 0100

         * 100

         * 0x100

                  

###02.04_Java语言基础(任意进制到十进制的转换图解)(了解)

* A:任意进制到十进制的转换原理

         * 系数:就是每一位上的数据。

         * 基数:X进制,基数就是X。

         * 权:在右边,从0开始编号,对应位上的编号即为该位的权。

         * 结果:把系数*基数的权次幂相加即可。

* B:画图练习

         * 二进制--十进制

         * 八进制--十进制

         * 十六进制--十进制

 

###02.05_Java语言基础(十进制到任意进制的转换图解)(了解)

* A:十进制到任意进制的转换原理

         * 除积倒取余

* B:画图练习

         * 十进制--二进制

         * 十进制--八进制

         * 十进制--十六进制

        

###02.06_Java语言基础(快速的进制转换法)(了解)

* A:8421码及特点

         * 8421码是中国大陆的叫法,8421码是BCD代码中最常用的一种。在这种编码方式中每一位二值代码的1都是代表一个固定数值,把每一位的1代表的十进制数加起来,得到的结果就是它所代表的十进制数码。

* B:通过8421码的方式进行二进制和十进制的相互转换

* C:二进制到八进制的简易方式

* D:二进制到十六进制的简易方式

 

###02.07_Java语言基础(原码反码补码)(了解)

* A:为什么要学习原码反码补码?

         * 后面要学习强制类型转换,如果不知道有原反补会看不懂结果

* B:有符号数据表示法的几种方式

         * 原码

                   * 就是二进制定点表示法,即最高位为符号位,“0”表示正,“1”表示负,其余位表示数值的大小。

                   * 通过一个字节,也就是8个二进制位表示+7和-7

                   * 0(符号位)      0000111

                   * 1(符号位)      0000111

         * 反码

                   * 正数的反码与其原码相同;负数的反码是对其原码逐位取反,但符号位除外。

         * 补码

                   * 正数的补码与其原码相同;负数的补码是在其反码的末位加1。

 

###02.08_Java语言基础(原码反码补码的练习)(了解)

* A:已知原码求补码

         * 0b10110100

* B:已知补码求原码

         * 0b11101110

        

###02.09_Java语言基础(变量的概述及格式)(掌握)

* A:什么是变量

         * 在程序执行的过程中,在某个范围内其值可以发生改变的量

* B:变量的定义格式

         * 数据类型 变量名 = 变量值;

* C:为什么要定义变量

         * 用来不断的存放同一类型的常量,并可以重复使用

 

###02.10_Java语言基础(数据类型的概述和分类)(掌握)

* A:为什么有数据类型

         * Java语言是强类型语言,对于每一种数据都定义了明确的具体数据类型,在内存中分配了不同大小的内存空间

* B:Java中数据类型的分类

         * 基本数据类型

         * 引用数据类型

                   * 面向对象部分讲解

* C:基本数据类型分类(4类8种)

         * 整数型

                   * byte 占一个字节  -128到127

                   * short 占两个字  -2^15~2^15-1

                   * int 占四个字节 -2^31~2^31-1

                   * long 占八个字节 -2^63~2^63-1

         * 浮点型

                   * float 占四个字节 -3.403E38~3.403E38  单精度

                   * double 占八个字节-1.798E308~1.798E308 双精度

         * 字符型

                   * char 占两个字节 0~65535

         * 布尔型

                   * boolean  

                            * boolean理论上是占八分之一个字节,因为一个开关就可以决定是true和false了,但是java中boolean类型没有明确指定他的大小     

 

###02.11_Java语言基础(定义不同数据类型的变量)(掌握)

* A:案例演示

         * 定义不同基本数据类型的变量,并输出

         * 赋值时候注意float类型,long类型

 

###02.12_Java语言基础(使用变量的注意事项)(掌握)

* A:案例演示

         * a:作用域问题

                   * 同一个区域不能使用相同的变量名

         * b:初始化值问题

                   * 局部变量在使用之前必须赋值

         * c:一条语句可以定义几个变量

                   * int a,b,c...;

 

###02.13_Java语言基础(数据类型转换之隐式转换)(掌握)

* A:案例演示

         * a:int + int

         * b:byte + int

* B:Java中的默认转换规则

         * 取值范围小的数据类型与取值范围大的数据类型进行运算,会先将小的数据类型提升为大的,再运算

* C:画图解释byte+int类型的问题

 

###02.14_Java语言基础(数据类型转换之强制转换)(掌握)

* A:强制转换问题

         * int a = 10;

         * byte b = 20;

         * b = a + b;

* B:强制转换的格式

         * b = (byte)(a + b);

* C:强制转换的注意事项

         * 如果超出了被赋值的数据类型的取值范围得到的结果会与你期望的结果不同

 

###02.15_Java语言基础(面试题之变量相加和常量相加的区别)(掌握)

* A:案例演示

         * 面试题:看下面的程序是否有问题,如果有问题,请指出并说明理由。

         * byte b1 = 3;

         * byte b2 = 4;

         * byte b3 = b1 + b2;

                   * 从两方面去回答这个题

                   * b1和b2是两个变量,变量里面存储的值都是变化的,所以在程序运行中JVM是无法判断里面具体的值

                   * byte类型的变量在进行运算的时候,会自动类型提升为int类型

         * byte b4 = 3 + 4;

                   * 3和4都是常量,java有常量优化机制,就是在编译的的时候直接把3和4的结果赋值给b4了

                  

###02.16_Java语言基础(long与float的取值范围谁大谁小)(了解)

* 进行混合运算的时候,byte,short,char不会相互转换,都会自动类型提升为int类型,其他类型进行混合运算的是小的数据类型提升为大的

         * byte,short,char -- int -- long -- float -- double

        

         * long: 8个字节

         * float:4个字节

         * IEEE754

         * 4个字节是32个二进制位

         * 1位是符号位

         * 8位是指数位

         * 00000000   11111111

         * 0到255

         * 1到254

         * -126到127

         * 23位是尾数位

         * 每个指数位减去127

        

         * A:它们底层的存储结构不同。

         * B:float表示的数据范围比long的范围要大

                   * long:2^63-1

                   * float:3.4*10^38 > 2*10^38 > 2*8^38 = 2*2^3^38 = 2*2^114 > 2^63-1

 

###02.17_Java语言基础(字符和字符串参与运算)(掌握)

* A:案例演示

         * System.out.println('a');

         * System.out.println('a'+1);

        

         * 通过看结果知道'a'的值是多少,由此引出ASCII码表

* B:ASCII码表的概述

         * 记住三个值:

                   * '0'  48

                   * 'A'  65

                   * 'a'  97

* C:案例演示

         * System.out.println("hello"+'a'+1);

         * System.out.println('a'+1+"hello");

* D:+在有字符串参与中被称为字符串连接符

         * System.out.println("5+5="+5+5);

         * System.out.println(5+5+"=5+5");

        

###02.18_Java语言基础(char数据类型)(掌握)

* A:char c = 97;        0到65535

* B:Java语言中的字符char可以存储一个中文汉字吗?为什么呢?

         * 可以。因为Java语言采用的是Unicode编码。Unicode编码中的每个字符占用两个字节。中文也是占的两个字节

         * 所以,Java中的字符可以存储一个中文汉字

###02.19_Java语言基础(算术运算符的基本用法)(掌握)

* A:什么是运算符

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

* B:运算符的分类

         * 算术运算符,赋值运算符,比较(关系或条件)运算符,逻辑运算符,位运算符,三目(元)运算符

* C:算数运算符有哪些

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

* D:注意事项:

         * a:+号在java中有三种作用,代表正号,做加法运算,字符串的连接符

         * b:整数相除只能得到整数。如果想得到小数,必须把数据变化为浮点数类型

         * c:/获取的是除法操作的商,%获取的是除法操作的余数

         * %运算符

                   * 当左边的绝对值小于右边绝对值时,结果是左边

                   * 当左边的绝对值等于右边或是右边的倍数时,结果是0

                   * 当左边的绝对值大于右边绝对值时,结果是余数

                   * %运算符结果的符号只和左边有关系,与右边无关

                   * 任何一个正整数%2结果不是0就是1可以用来当作切换条件

 

###02.20_Java语言基础(算术运算符++和--的用法)(掌握)

* A:++,--运算符的作用

         * 自加(++)自减(--)运算

         * ++:自加。对原有的数据进行+1

         * --:自减。对原有的数据进行-1

* B:案例演示

         * a:单独使用:

                   * 放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)

         * b:参与运算使用:

                   * 放在操作数的前面,先自增或者自减,然后再参与运算。

                   * 放在操作数的后面,先参与运算,再自增或者自减。

 

###02.21_Java语言基础(算术运算符++和--的练习)(掌握)

* A:案例演示

         * 请分别计算出a,b,c的值?

         *

                            int a = 10;

                            int b = 10;

                            int c = 10;

                  

                            a = b++;            

                            c = --a;                        

                            b = ++a;            

                            a = c--;                        

        

* B:案例演示

         * 请分别计算出x,y的值?

        

                            int x = 4;

                            int y = (x++)+(++x)+(x*10);

* C:面试题

         * byte b = 10;

         * b++;

         * b = b + 1;

         * 问哪句会报错,为什么

 

###02.22_Java语言基础(赋值运算符的基本用法)(掌握)

* A:赋值运算符有哪些

         * a:基本的赋值运算符:=

                   * 把=右边的数据赋值给左边。

                  

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

                   * += 把左边和右边做加法,然后赋值给左边。

        

###02.23_Java语言基础(赋值运算符的面试题)(掌握)

* A:案例演示

         * 面试题:看下面的程序是否有问题,如果有问题,请指出并说明理由。

         * short s=1;s = s+1;

         * short s=1;s+=1;

 

###02.24_Java语言基础(关系运算符的基本用法及其注意事项)(掌握)

* A:关系运算符有哪些(比较运算符,条件运算符)

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

* 注意事项:

         * 无论你的操作是简单还是复杂,结果是boolean类型。

        

         * "=="不能写成"="。

 

###03.01_Java语言基础(逻辑运算符的基本用法)(掌握)

* A:逻辑运算符有哪些

         * &,|,^,!

         * &&,||

* B:案例演示

* 逻辑运算符的基本用法

        

* 注意事项:

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

         * b:表达式:就是用运算符把常量或者变量连接起来的符合java语法的式子。

                   * 算术表达式:a + b

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

* C:结论:

* &逻辑与:有false则false。

* |逻辑或:有true则true。

* ^逻辑异或:相同为false,不同为true。

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

         * 特点:偶数个不改变本身。

 

###03.02_Java语言基础(逻辑运算符&&和&的区别)(掌握)

* A:案例演示

         * &&和&的区别?

                   * a:最终结果一样。

                   * b:&&具有短路效果。左边是false,右边不执行。

                   *      &是无论左边是false还是true,右边都会执行

* B:同理||和|的区别?(学生自学)

* C:开发中常用谁?

         * &&,||,!

 

###03.03_Java语言基础(位运算符的基本用法1)(了解)

* A:位运算符有哪些

         * &,|,^,~ ,>>,>>>,<<

* B:案例演示

         * 位运算符的基本用法1

        

         * &,|,^,~ 的用法

         * &:有0则0

         * |:有1则1

         * ^:相同则0,不同则1

         * ~:按位取反

 

###03.04_Java语言基础(位异或运算符的特点及面试题)(掌握)

* A:案例演示

         * 位异或运算符的特点

 

         * ^的特点:一个数据对另一个数据位异或两次,该数本身不变。

        

* B:面试题:

         * 请自己实现两个整数变量的交换

         * 注意:以后讲课的过程中,我没有明确指定数据的类型,默认int类型。

 

###03.05_Java语言基础(位运算符的基本用法2及面试题)(了解)

* A:案例演示 >>,>>>,<<的用法:

         *  <<:左移      左边最高位丢弃,右边补齐0

         *  >>:右移      最高位是0,左边补齐0;最高为是1,左边补齐1

         *  >>>:无符号右移 无论最高位是0还是1,左边补齐0

         *  最有效率的算出2 * 8的结果

 

###03.06_Java语言基础(三元运算符的基本用法)(掌握)

* A:三元运算符的格式

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

* B:三元运算符的执行流程

* C:案例演示

         * 获取两个数中的最大值

 

###03.07_Java语言基础(三元运算符的练习)(掌握)

* A:案例演示

         * 比较两个整数是否相同

* B:案例演示

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

 

###03.08_Java语言基础(键盘录入的基本格式讲解)(掌握)

* A:为什么要使用键盘录入数据

         * a:为了让程序的数据更符合开发的数据

         * b:让程序更灵活一下

* B:如何实现键盘录入呢?

         * 先照格式来。

         * a:导包

                   * 格式:

                            * import java.util.Scanner;

                   * 位置:

                            * 在class上面。

         * b:创建键盘录入对象

                   * 格式:

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

         * c:通过对象获取数据  

                   * 格式:

                            * int x = sc.nextInt();

* C:案例演示

         * 键盘录入1个整数,并输出到控制台。

         * 键盘录入2个整数,并输出到控制台。

 

###03.09_Java语言基础(键盘录入的练习1)(掌握)

* A:案例演示

         * 键盘录入练习:键盘录入两个数据,并对这两个数据求和,输出其结果

* B:案例演示

         * 键盘录入练习:键盘录入两个数据,获取这两个数据中的最大值

 

###03.10_Java语言基础(键盘录入的练习2)(掌握)

* A:案例演示

         * 键盘录入练习:键盘录入两个数据,比较这两个数据是否相等

* B:案例演示

         * 键盘录入练习:键盘录入三个数据,获取这三个数据中的最大值

 

###03.11_Java语言基础(顺序结构语句)(了解)

* A:什么是流程控制语句

         * 流程控制语句:可以控制程序的执行流程。

* B:流程控制语句的分类

         * 顺序结构

         * 选择结构

         * 循环结构

* C:执行流程:

         * 从上往下,依次执行。

* D:案例演示

         * 输出几句话看效果即可

 

###03.12_Java语言基础(选择结构if语句格式1及其使用)(掌握)

* A:选择结构的分类

         * if语句

         * switch语句

* B:if语句有几种格式

         * 格式1

         * 格式2

         * 格式3

* C:if语句的格式1

*

                   if(比较表达式) {

                            语句体;

                   }

* D:执行流程:

         * 先计算比较表达式的值,看其返回值是true还是false。

         * 如果是true,就执行语句体;

         * 如果是false,就不执行语句体;

 

###03.13_Java语言基础(选择结构if语句注意事项)(掌握)

* A:案例演示

         * a:比较表达式无论简单还是复杂,结果必须是boolean类型

         * b:if语句控制的语句体如果是一条语句,大括号可以省略;

           * 如果是多条语句,就不能省略。建议永远不要省略。

         * c:一般来说:有左大括号就没有分号,有分号就没有左大括号

 

###03.14_Java语言基础(选择结构if语句格式2及其使用)(掌握)

* A:if语句的格式2

*

                   if(比较表达式) {

                            语句体1;

                   }else {

                            语句体2;

                   }

* B:执行流程:

         * 首先计算比较表达式的值,看其返回值是true还是false。

         * 如果是true,就执行语句体1;

         * 如果是false,就执行语句体2;

* C:案例演示

         * a:获取两个数据中较大的值

         * b:判断一个数据是奇数还是偶数,并输出是奇数还是偶数

 

         * 注意事项:else后面是没有比较表达式的,只有if后面有。

 

###03.15_Java语言基础(if语句的格式2和三元的相互转换问题)(掌握)

* A:案例演示

         * if语句和三元运算符完成同一个效果

* B:案例演示

         * if语句和三元运算符的区别

        

         * 三元运算符实现的,都可以采用if语句实现。反之不成立。

        

         * 什么时候if语句实现不能用三元改进呢?

                   * 当if语句控制的操作是一个输出语句的时候就不能。

                   * 为什么呢?因为三元运算符是一个运算符,运算符操作完毕就应该有一个结果,而不是一个输出。

 

###03.16_Java语言基础(选择结构if语句格式3及其使用)(掌握)

* A:if语句的格式3:

*

                   if(比较表达式1) {

                            语句体1;

                   }else if(比较表达式2) {

                            语句体2;

                   }else if(比较表达式3) {

                            语句体3;

                   }

                   ...

                   else {

                            语句体n+1;

                   }

* B:执行流程:

         * 首先计算比较表达式1看其返回值是true还是false,

         * 如果是true,就执行语句体1,if语句结束。

         * 如果是false,接着计算比较表达式2看其返回值是true还是false,

        

         * 如果是true,就执行语句体2,if语句结束。

         * 如果是false,接着计算比较表达式3看其返回值是true还是false,

        

         * 如果都是false,就执行语句体n+1。

* C:注意事项:最后一个else可以省略,但是建议不要省略,可以对范围外的错误值提示

 

###03.17_Java语言基础(选择结构if语句格式3练习)(掌握)

* A:练习1

*

                   需求:键盘录入一个成绩,判断并输出成绩的等级。

                   90-100 优

                   80-89  良

                   70-79  中

                   60-69  及

                   0-59   差

                  

* B:练习2

         * 需求:

                   * 键盘录入x的值,计算出y的并输出。

                  

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

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

                   * x<=-1     y = 2 * x - 1;

 

###03.18_Java语言基础(选择结构if语句的嵌套使用)(掌握)

* A:案例演示

         * 需求:获取三个数据中的最大值

         * if语句的嵌套使用。

 

###03.19_Java语言基础(选择结构switch语句的格式及其解释)(掌握)

* A:switch语句的格式

*

                   switch(表达式) {

                         case 值1:

                                     语句体1;

                                     break;

                                case 值2:

                                     语句体2;

                                     break;

                                …

                                default:

                                     语句体n+1;

                                     break;

             }

 

* B:switch语句的格式解释

* C:面试题

         * byte可以作为switch的表达式吗?

         * long可以作为switch的表达式吗?

         * String可以作为switch的表达式吗?

* C:执行流程

         * 先计算表达式的值

         * 然后和case后面的匹配,如果有就执行对应的语句,否则执行default控制的语句

 

###03.20_Java语言基础(选择结构switch语句的练习)(掌握)

* A:整数(给定一个值,输出对应星期几)

 

###03.21_Java语言基础(选择结构switch语句的注意事项)(掌握)

* A:案例演示

         * a:case后面只能是常量,不能是变量,而且,多个case后面的值不能出现相同的

         * b:default可以省略吗?

                   * 可以省略,但是不建议,因为它的作用是对不正确的情况给出提示。

                   * 特殊情况:

                            * case就可以把值固定。

                            * A,B,C,D

         * c:break可以省略吗?

                   * 最后一个可以省略,其他最好不要省略

                   * 会出现一个现象:case穿透。

                   * 最终我们建议不要省略

         * d:default一定要在最后吗?

                   * 不是,可以在任意位置。但是建议在最后。

         * e:switch语句的结束条件

                   * a:遇到break就结束了

                   * b:执行到switch的右大括号就结束了

 

###03.22_Java语言基础(选择结构switch语句练习)(掌握)

* A:看程序写结果:

*

                   int x = 2;

                   int y = 3;

                   switch(x){

                            default:

                                     y++;

                                     break;

                            case 3:

                                     y++;

                            case 4:

                                     y++;

                   }

                   System.out.println("y="+y);

        

* B:看程序写结果:

*

                   int x = 2;

                   int y = 3;

                   switch(x){

                            default:

                                     y++;

                            case 3:

                                     y++;

                            case 4:

                                     y++;

                   }

                   System.out.println("y="+y);

 

###03.23_Java语言基础(选择结构if语句和switch语句的区别)(掌握)

* A:总结switch语句和if语句的各自使用场景

*      switch建议判断固定值的时候用

*      if建议判断区间或范围的时候用

* B:案例演示

         * 分别用switch语句和if语句实现下列需求:

                   * 键盘录入月份,输出对应的季节

 

###04.01_Java语言基础(循环结构概述和for语句的格式及其使用)

* A:循环结构的分类

         * for,while,do...while

* B:循环结构for语句的格式:

*

                   for(初始化表达式;条件表达式;循环后的操作表达式) {

                            循环体;

                   }

* C执行流程:

         * a:执行初始化语句

         * b:执行判断条件语句,看其返回值是true还是false

                   * 如果是true,就继续执行

                   * 如果是false,就结束循环

         * c:执行循环体语句;

         * d:执行循环后的操作表达式

         * e:回到B继续。

* D:案例演示

         * 在控制台输出10次"helloworld"

        

###04.02_Java语言基础(循环结构for语句的练习之获取数据)

* A:案例演示

         * 需求:请在控制台输出数据1-10

         * 需求:请在控制台输出数据10-1

* B:注意事项

         * a:判断条件语句无论简单还是复杂结果是boolean类型。

         * b:循环体语句如果是一条语句,大括号可以省略;如果是多条语句,大括号不能省略。建议永远不要省略。

         * c:一般来说:有左大括号就没有分号,有分号就没有左大括号

 

###04.03_Java语言基础(循环结构for语句的练习之求和思想)

* A:案例演示

         * 需求:求出1-10之间数据之和

* B:学生练习

         * 需求:求出1-100之间偶数和

         * 需求:求出1-100之间奇数和

 

###04.04_Java语言基础(循环结构for语句的练习之水仙花)

* A:案例演示

         * 需求:在控制台输出所有的”水仙花数”

 

         * 所谓的水仙花数是指一个三位数,其各位数字的立方和等于该数本身。

         * 举例:153就是一个水仙花数。

         * 153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153

 

###04.05_Java语言基础(循环结构for语句的练习之统计思想)

* A:案例演示

         * 需求:统计”水仙花数”共有多少个

 

###04.06_Java语言基础(循环结构while语句的格式和基本使用)

* A:循环结构while语句的格式:

*              

                   while循环的基本格式:

                   while(判断条件语句) {

                            循环体语句;

                   }

                  

                   完整格式:

                  

                   初始化语句;

             while(判断条件语句) {

                             循环体语句;

                             控制条件语句;

                   }

* B:执行流程:

         * a:执行初始化语句

         * b:执行判断条件语句,看其返回值是true还是false

                   * 如果是true,就继续执行

                   * 如果是false,就结束循环

         * c:执行循环体语句;

         * d:执行控制条件语句

         * e:回到B继续。

* C:案例演示

         * 需求:请在控制台输出数据1-10

 

###04.07_Java语言基础(循环结构while语句的练习)

* A:求和思想

         * 求1-100之和

* B:统计思想

         * 统计”水仙花数”共有多少个

 

###04.08_Java语言基础(循环结构do...while语句的格式和基本使用)

* A:循环结构do...while语句的格式:

*

                   do {

                            循环体语句;

                   }while(判断条件语句);

                  

                   完整格式;

                   初始化语句;

                   do {

                            循环体语句;

                            控制条件语句;

                   }while(判断条件语句);

* B:执行流程:

         * a:执行初始化语句

         * b:执行循环体语句;

         * c:执行控制条件语句

         * d:执行判断条件语句,看其返回值是true还是false

                   * 如果是true,就继续执行

                   * 如果是false,就结束循环

         * e:回到b继续。

* C:案例演示

         * 需求:请在控制台输出数据1-10

 

###04.09_Java语言基础(循环结构三种循环语句的区别)

* A:案例演示

         * 三种循环语句的区别:

         * do...while循环至少执行一次循环体。

         * 而for,while循环必须先判断条件是否成立,然后决定是否执行循环体语句。

* B:案例演示

         * for循环和while循环的区别:

                   * A:如果你想在循环结束后,继续使用控制条件的那个变量,用while循环,否则用for循环。不知道用谁就用for循环。因为变量及早的从内存中消失,可以提高内存的使用效率。

                                    

###04.10_Java语言基础(循环结构注意事项之死循环)

* A:一定要注意控制条件语句控制的那个变量的问题,不要弄丢了,否则就容易死循环。

* B:两种最简单的死循环格式

         * while(true){...}

         * for(;;){...}

 

###04.11_Java语言基础(循环结构循环嵌套输出4行5列的星星)

* A:案例演示

         * 需求:请输出一个4行5列的星星(*)图案。

         *

                            如图:

                                     *****

                                     *****

                                     *****

                                     *****

                                    

                            注意:

                                     System.out.println("*");和System.out.print("*");的区别

* B:结论:

         * 外循环控制行数,内循环控制列数

 

###04.12_Java语言基础(循环结构循环嵌套输出正三角形)

* A:案例演示

*

                   需求:请输出下列的形状

                   *

                   **

                   ***

                   ****

                   *****

 

###04.13_Java语言基础(循环结构九九乘法表)

* A:案例演示

         * 需求:在控制台输出九九乘法表。

* B:代码优化

*

                   注意:

                   'x' x表示任意,是转义符号,这种做法叫转移字符。

                  

                   't'    tab键的位置

                   'r'    回车

                   'n'   换行

                   '"'

                   '''

 

        

###04.14_Java语言基础(控制跳转语句break语句)

* A:break的使用场景

         * 只能在switch和循环中

 

###04.15_Java语言基础(控制跳转语句continue语句)

* A:continue的使用场景

         * 只能在循环中

 

###04.16_Java语言基础(控制跳转语句标号)

* 标号:标记某个循环对其控制

* 标号组成规则:其实就是合法的标识符

 

###04.17_Java语言基础(控制调整语句练习)

* A:练习题

*

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

                            if(x%3==0) {

                                     //在此处填写代码

                            }

                            System.out.println(“Java基础班”);

                   }

                  

                   我想在控制台输出2次:“Java基础班“

                   我想在控制台输出7次:“Java基础班“

                   我想在控制台输出13次:“Java基础班“

 

 

###04.18_Java语言基础(控制跳转语句return语句)

* A:return的作用

         * 返回

         * 其实它的作用不是结束循环的,而是结束方法的。

* B:案例演示

         * return和break以及continue的区别?

         * return是结束方法

         * break是跳出循环

         * continue是终止本次循环继续下次循环

 

 

###04.19_Java语言基础(方法概述和格式说明)

* A:为什么要有方法

         * 提高代码的复用性

* B:什么是方法

         * 完成特定功能的代码块。

* C:方法的格式

*

                   修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {

                            方法体语句;

                            return 返回值;

                   }

* D:方法的格式说明

         * 修饰符:目前就用 public static。后面我们再详细的讲解其他的修饰符。

         * 返回值类型:就是功能结果的数据类型。

         * 方法名:符合命名规则即可。方便我们的调用。

         * 参数:

                   * 实际参数:就是实际参与运算的。

                   * 形式参数;就是方法定义上的,用于接收实际参数的。

         * 参数类型:就是参数的数据类型

         * 参数名:就是变量名

         * 方法体语句:就是完成功能的代码。

         * return:结束方法的。

         * 返回值:就是功能的结果,由return带给调用者。

 

###04.20_Java语言基础(方法之求和案例及其调用)

* A:如何写一个方法

         * 1,明确返回值类型

         * 2,明确参数列表

* B:案例演示

         * 需求:求两个数据之和的案例

* C:方法调用图解

 

###04.21_Java语言基础(方法的注意事项)

* A:方法调用(有具体返回值)

         * a:单独调用,一般来说没有意义,所以不推荐。

         * b:输出调用,但是不够好。因为我们可能需要针对结果进行进一步的操作。

         * c:赋值调用,推荐方案。

* B:案例演示

         * a:方法不调用不执行

         * b:方法与方法是平级关系,不能嵌套定义

         * c:方法定义的时候参数之间用逗号隔开

         * d:方法调用的时候不用在传递数据类型

         * e:如果方法有明确的返回值,一定要有return带回一个值

 

###04.22_Java语言基础(方法的练习)

* A:案例演示

         * 需求:键盘录入两个数据,返回两个数中的较大值

* B:案例演示

         * 需求:键盘录入两个数据,比较两个数是否相等    

 

 

###04.23_Java语言基础(方法之输出星形及其调用)

* A:案例演示

         * 需求:根据键盘录入的行数和列数,在控制台输出星形

* B:方法调用:(无返回值,void)

         * 单独调用

         * 输出调用(错误)

         * 赋值调用(错误)

 

###04.24_Java语言基础(方法的练习)

* A:案例演示

         * 需求:根据键盘录入的数据输出对应的乘法表

 

###04.25_Java语言基础(方法重载概述和基本使用)

* A:方法重载概述

         * 求和案例

                   * 2个整数

                   * 3个整数

                   * 4个整数

* B:方法重载:

         * 在同一个类中,方法名相同,参数列表不同。与返回值类型无关。

        

         * 参数列表不同:

                   * A:参数个数不同

                   * B:参数类型不同

                   * C:参数的顺序不同(算重载,但是在开发中不用)

 

 

###04.26_Java语言基础(方法重载练习比较数据是否相等)

* A:案例演示

         * 需求:比较两个数据是否相等。

         * 参数类型分别为两个int类型,两个double类型,并在main方法中进行测试

 

###05.01_Java语言基础(数组概述和定义格式说明)(了解)

* A:为什么要有数组(容器)

         * 为了存储同种数据类型的多个值

* B:数组概念

         * 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。

         * 数组既可以存储基本数据类型,也可以存储引用数据类型。

 

* C:数组定义格式

         数据类型[] 数组名 = new 数据类型[数组的长度];

###05.02_Java语言基础(数组的初始化动态初始化)(掌握)

* A:什么是数组的初始化

         * 就是为数组开辟连续的内存空间,并为每个数组元素赋予值

* B:如何对数组进行初始化

         * a:动态初始化 只指定长度,由系统给出初始化值

                   * int[] arr = new int[5];  

         * b:静态初始化 给出初始化值,由系统决定长度    

* C:动态初始化的格式:

         * 数据类型[] 数组名 = new 数据类型[数组长度];

* D:案例演示

         * 输出数组名称和数组元素

 

###05.03_Java语言基础(Java中的内存分配以及栈和堆的区别)

* A:栈(掌握)

         * 存储局部变量

* B:堆(掌握)

         * 存储new出来的数组或对象

* C:方法区

         * 面向对象部分讲解

* D:本地方法区

         * 和系统相关

* E:寄存器

         * 给CPU使用

###05.04_Java语言基础(数组的内存图解1一个数组)(掌握)

* A:画图演示

         * 一个数组

 

###05.05_Java语言基础(数组的内存图解2二个数组)(了解)

* A:画图演示

         * 二个不同的数组

 

###05.06_Java语言基础(数组的内存图解3三个引用两个数组)(了解)

* A:画图演示

         * 三个引用,有两个数组的引用指向同一个地址

 

###05.07_Java语言基础(数组的初始化静态初始化及内存图)(掌握)

* A:静态初始化的格式:

         * 格式:数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};

         * 简化格式:

                   * 数据类型[] 数组名 = {元素1,元素2,…};

* B:案例演示

         * 对数组的解释

         * 输出数组名称和数组元素

* C:画图演示

         * 一个数组

 

###05.08_Java语言基础(数组操作的两个常见小问题越界和空指针)(掌握)

* A:案例演示

         * a:ArrayIndexOutOfBoundsException:数组索引越界异常

                   * 原因:你访问了不存在的索引。

         * b:NullPointerException:空指针异常

                   * 原因:数组已经不在指向堆内存了。而你还用数组名去访问元素。

                   * int[] arr = {1,2,3};

                   * arr = null;

                   * System.out.println(arr[0]);

 

###05.09_Java语言基础(数组的操作1遍历)(掌握)

* A:案例演示

         * 数组遍历:就是依次输出数组中的每一个元素。

         * 数组的属性:arr.length数组的长度

         * 数组的最大索引:arr.length - 1;

          

                            public static void print(int[] arr) {

                                     for (int i = 0;i < arr.length ;i++ ) {

                                               System.out.print(arr[i]

  • " ");

                                     }

                            }

 

###05.10_Java语言基础(数组的操作2获取最值)(掌握)

* A:案例演示

         * 数组获取最值(获取数组中的最大值最小值)

                  

                            public static int getMax(int[] arr) {

                                     int max = arr[0];

                                     for (int i = 1;i < arr.length ;i++ ) {                         //从数组的第二个元素开始遍历

                                               if (max < arr[i]) {                                                               //如果max记录的值小于的数组中的元素

                                                        max = arr[i];                                                             //max记录住较大的

                                               }

                                     }

                  

                                     return max;

                            }

###05.11_Java语言基础(数组的操作3反转)(掌握)

* A:案例演示

         * 数组元素反转(就是把元素对调)

                           

                            public static void reverseArray(int[] arr) {

                                     for (int i = 0;i < arr.length / 2 ; i++) {

                                               //arr[0]和arr[arr.length-1-0]交换

                                               //arr[1]和arr[arr.length-1-1]交换

                                               //arr[2]和arr[arr.lentth-1-2]

                                               //...

                  

                                               int temp = arr[i];

                                               arr[i] = arr[arr.length-1-i];

                                               arr[arr.length-1-i] = temp;

                                     }

                            }

 

###05.12_Java语言基础(数组的操作4查表法)(掌握)

* A:案例演示

         * 数组查表法(根据键盘录入索引,查找对应星期)

        

                            public static char getWeek(int week) {

                                     char[] arr = {' ','一','二','三','四','五','六','日'};                  //定义了一张星期表

                                     return arr[week];                                                                                                  //通过索引获取表中的元素

                            }

 

###05.13_Java语言基础(数组的操作5基本查找)(掌握)

* A:案例演示

         * 数组元素查找(查找指定元素第一次在数组中出现的索引)

        

                            public static int getIndex(int[] arr,int value) {

                                     for (int i = 0;i < arr.length ;i++ ) {                                  //数组的遍历

                                               if (arr[i] == value) {                                                           //如果数组中的元素与查找的元素匹配

                                                        return i;

                                               }

                                     }

                                     return -1;

                            }

 

###05.14_Java语言基础(二维数组概述和格式1的讲解)(了解)

* A:二维数组概述

* B:二维数组格式1

         * int[][] arr = new int[3][2];

* C:二维数组格式1的解释

* D:注意事项

         * a:以下格式也可以表示二维数组

                   * 1:数据类型 数组名[][] = new 数据类型[m][n];

                   * 2:数据类型[] 数组名[] = new 数据类型[m][n];

         * B:注意下面定义的区别

         *

                            int x;

                            int y;

                            int x,y;

                           

                            int[] x;

                            int[] y[];

                           

                            int[] x,y[]; x是一维数组,y是二维数组

* E:案例演示

         * 定义二维数组,输出二维数组名称,一维数组名称,一个元素

 

###05.15_Java语言基础(二维数组格式1的内存图解)(了解)

* A:画图演示

         * 画图讲解上面的二维数组名称,一维数组名称,一个元素的值的问题

 

###05.16_Java语言基础(二维数组格式2的讲解及其内存图解)(了解)

* A:二维数组格式2

         * int[][] arr = new int[3][];

* B:二维数组格式2的解释

* C:案例演示

         * 讲解格式,输出数据,并画内存图

 

###05.17_Java语言基础(二维数组格式3的讲解及其内存图解)(了解)

* A:二维数组格式3

         * int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};

* B:二维数组格式3的解释

* C:案例演示

         * 讲解格式,输出数据,并画内存图

 

###05.18_Java语言基础(二维数组练习1遍历)(掌握)

* A:案例演示

         * 需求:二维数组遍历

 

         * 外循环控制的是二维数组的长度,其实就是一维数组的个数。

         * 内循环控制的是一维数组的长度。

 

                            int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};

        

                            for (int i = 0;i < arr.length ;i++ ) {                         //获取到每个二维数组中的一维数组

                                     for (int j = 0;j < arr[i].length ;j++ ) {  //获取每个一维数组中的元素

                                               System.out.print(arr[i][j] + " ");

                                     }

        

                                     System.out.println();

                            }

###05.19_Java语言基础(二维数组练习2求和)(掌握)

* A:案例演示

*

                   需求:公司年销售额求和

                   某公司按照季度和月份统计的数据如下:单位(万元)

                   第一季度:22,66,44

                   第二季度:77,33,88

                   第三季度:25,45,65

                   第四季度:11,66,99

                  

                   int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};

 

                   int sum = 0;                                                                                 //定义变量,记录每次相加的结果

                   for (int i = 0;i < arr.length ;i++ ) {                         //获取每一个一维数组

                            for (int j = 0;j < arr[i].length ;j++ ) {  //获取每一个一维数组中的元素

                                     sum = sum + arr[i][j];                                             //累加

                            }

                   }

 

                   System.out.println(sum);

###05.20_Java语言基础(思考题Java中的参数传递问题及图解)(掌握)

* A:案例演示

*

                   看程序写结果,并画内存图解释

                   public static void main(String[] args) {

                            int a = 10;

                            int b = 20;

                            System.out.println("a:"+a+",b:"+b);

                            change(a,b);

                            System.out.println("a:"+a+",b:"+b);

        

                            int[] arr = {1,2,3,4,5};

                            change(arr);

                            System.out.println(arr[1]);

                   }

        

                   public static void change(int a,int b) {

                            System.out.println("a:"+a+",b:"+b);

                            a = b;

                            b = a + b;

                            System.out.println("a:"+a+",b:"+b);

                   }

        

                   public static void change(int[] arr) {

                            for(int x=0; x<arr.length; x++) {

                                     if(arr[x]%2==0) {

                                               arr[x]*=2;

                                     }

                            }

                   }

 

本文由加拿大28走势图发布于数码,转载请注明出处:java语言基础

您可能还会对下面的文章感兴趣: