Java笔记

byte的取值范围为-128~127，占用1个字节（-2的7次方到2的7次方-1）
short的取值范围为-32768~32767，占用2个字节（-2的15次方到2的15次方-1）
int的取值范围为（-2147483648~2147483647），占用4个字节（-2的31次方到2的31次方-1）
long的取值范围为（-9223372036854774808~9223372036854774807），占用8个字节（-2的63次方到2的63次方-1）

关键字

描述

abstract

抽象方法，抽象类的修饰符

assert

断言条件是否满足

boolean

布尔数据类型

break

跳出循环或者label代码段

byte

8-bit 有符号数据类型

case

switch语句的一个条件

catch

和try搭配扑捉异常信息

char

16-bit Unicode字符数据类型

class

定义类

const

未使用

continue

不执行循环体剩余部分

default

switch语句中的默认分支

do

循环语句，循环体至少会执行一次

double

64-bit双精度浮点数

else

if条件不成立时执行的分支

enum

枚举类型

extends

表示一个类是另一个类的子类

final

表示一个值在初始化之后就不能再改变了
表示方法不能被重写，或者一个类不能有子类

finally

为了完成执行的代码而设计的，主要是为了程序的健壮性和完整性，无论有没有异常发生都执行代码。

float

32-bit单精度浮点数

for

for循环语句

goto

未使用

if

条件语句

implements

表示一个类实现了接口

import

导入类

instanceof

测试一个对象是否是某个类的实例

int

32位整型数

interface

接口，一种抽象的类型，仅有方法和常量的定义

long

64位整型数

native

表示方法用非java代码实现

new

分配新的类实例

package

一系列相关类组成一个包

private

表示私有字段，或者方法等，只能从类内部访问

protected

表示字段只能通过类或者其子类访问
子类或者在同一个包内的其他类

public

表示共有属性或者方法

return

方法返回值

short

16位数字

static

表示在类级别定义，所有实例共享的

strictfp

浮点数比较使用严格的规则

super

表示基类

switch

选择语句

synchronized

表示同一时间只能由一个线程访问的代码块

this

表示调用当前实例
或者调用另一个构造函数

throw

抛出异常

throws

定义方法可能抛出的异常

transient

修饰不要序列化的字段

try

表示代码块要做异常处理或者和finally配合表示是否抛出异常都执行finally中的代码

void

标记方法不返回任何值

volatile

标记字段可能会被多个线程同时访问，而不做同步

while

while循环
————————————————

 

 

cmd
cd 文件夹名 进入文件夹
cd .. 上一级
cd 文件夹1/文件夹2/文件夹3 进入多级文件夹
cd/ 根目录
dir 当前文件夹目录
cls 清空屏幕
exit 退出

Java虚拟机 jvm
JRE 核心库
JDK 开发工具包

环境变量

uff08 uff09 中文改英文 字符违法 名字别加空格

==1_12

 

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

第2节
HelloWorld案例

 

=====1.13
程序注释与HelloWorld说明

 

// 注释内容
//public class 后面代表定义一个类的名称 类是java'当中所有源代码的基本组织
//第一行的第三个单词必须和所在的文件名称一样 大小写也要一样
public class HelloWorld {
//第二行的内容是万年不变的固定写法 代表main方法
//这一行代表程序执行的起点
public static void main (String[] args) {
第三行代表打印输出的语句
希望显示什么东西 就在小括号中填写什么内容
System.out.println ("Hello,World!");
}
}

 

第3节
关键字&标识符

 

======1 _14
关键字的概念与特征

 

关键字特点
1 完全小写的字母
2 在增强版的记事本当中（例如 notepad++）有特殊颜色

标识符
标识符可以包含英文26个 （区分大小写） 0 -9 数字 $ 美元符号 _ 下划线
标识符不能以数字开头
标识符不能是关键字

类名规范：首字母大写 后面每个单词首字母大写 大驼峰式
变量名规范：首字母小写，后面每个单词首字母大写 小驼峰式
方法名规范：同变量名

常量：是程序运行期间 固定不变的量

常量的分类：
1.字符串常量：凡是用双引号引起来的部分，叫做字符串常量 例如：“abc”
2.整数常量：直接写上的数字，没有小数点。 例如100、 200
3.浮点数常量：直接写上的数字，有小数点。例如：2.5
4. 字符常量：凡是用单引号引起来的单个字符，就做字符常量。 例如‘A’
5.布尔常量：只有量中取值 true 、false
6.空常量： null。 代表没有任何数据

两个单引号中间必须有且仅有一个字符 没有不行 有两个不行

空常量不能直接用来打印输出

public class Demo01Const{
public static void main(String[]args){
//字符串常量
System.out.println("ABC");
}


}

第4节
常量&变量

 

1_18
基本数据类型

 

 

基本数据类型
整数型 byte short int long
浮点型 float double
字符型 char
布尔型 boolean

引用数据类型
字符串、数组、类、接口、Lambda

注意：
1.字符串不是基本类型 而是引用类型。
2.浮点型可能只是一个近似值，并非精确的值.
3.数据范围与字节数不一定相关，例如float数据范围比long更加广泛，但是float是4字节，long是8字节.
4.浮点数当中默认类型是double。如果一定要使用float类型，需要叫上一个后缀F
如果是整数，默认为int类型，如果一定要使用long类型，需要加上一个后缀L。推荐是用大写字母后缀。

1_19
变量的概念与定义格式

 

 

变量：程序运行期间，内容可以发生改变的量。

创建一个变量并且使用的格式：

数据类型 变量名称； //创建了一个变量
变量名称=数据值；//复制，讲右边的数据值，赋值交给左边的变量

一步到位的格式：

数据类型 变量名称=数据值；//在创建一个变量的同时，立刻放入指定的数据值

public class Demo02Variable{
public static void main(String[] args){
//创建一个变量
//格式：数据类型 变量名称；
int num1;
//向变量当中存入数据
//格式：变量名称=数据值；
num1=10;
//当打印输出变量名是 显示出来的是变量的内容
System.out.println(num1);

//改变变量当中本来的数字，变成新的数字
num1=20;
System.out.println(num1);//20

//使用一步到位你的格式来定义变量
//格式：数据类型 变量名称=数据类型；
int num2=25;
System.out.println(num2);//25

num2=35;
System.out.println(num2);//35
System.out.println("=================");

byte num3 = 30; //注意：右侧数值的范围不能超过左侧数据类型的取值范围
System.out.println(num3);//30
//byte num4 = 400; //右侧超出了byte数据范围，错误！

short num5 = 50;
System.out.println(num5);//50

long num6 = 300000000L;
System.out.println(num6);//300000000

float num7 = 2.5F;
System.out.println(num7);//2.5

double num8 = 1.2;
System.out.println(num8); //1.2

char ziful = 'A';
System.out.println(ziful);//A

ziful = '中';
System.out.println(ziful);//中

boolean var1 = true;
System.out.println(var1);//true

var1 = false;
System.out.println(var1);//false

//将一个变量的数据内容，赋值交给另一个变量
//右侧的变量名称var1已经存在，里面装的是false布尔值
//将右侧变量里面的false值，向左交给var2变量进行存储
boolean var2 = var1;
System.out.println(var2);//false
}

}

 

 

1_21
变量的注意事项

 

 

1.如果创建多个变量，那么变量之间的名称不可以重复
2.对于float和long类型来说，字母后缀F和L不要丢掉
3.如果使用byte或者short类型的变量，那么右侧的数据值范围不能超过左侧类型的范围。
4.没有进行赋值的变量，不能直接使用，一定要赋值以后，才能使用。
5.变量使用不能超过作用域的范围。
（作用域）：从定义变量的一行开始，一直到直接所属的大括号结束为止。
6.可以通过一个语句来创建多个变量，但是一般情况不推荐这么写

 

 

第5节
数据类型转换

 

2-1
数组类型转换 - 自动转换

 

/*
当数据类型不一样时，将会发生数据类型转换。

自动类型转换（隐式）
1.特点：代码不需要进行特殊处理，自动完成。
2.规则：数据范围从小到大。

强制类型转换（显式）
*/

public class Demo01DataType{
public static void main(String[]args){
System.out.println(1024);//这就是一个整数，默认就是int类型
System.out.println(3.14);//这就是一个浮点数，默认就是double类型。

//左边是long类型，右边是默认的int类型，左右不一样
//一个等号代表赋值，将右侧的int常量，交给左侧的long变量进行存储。
//int-->long.符合了数据范围从小到大的要求
//这一行代码发生了自动类型转换。
long num1 = 100;
System.out.println(num1);//100

//左边是double类型 右边是float类型，左右不一样
//float--》double，符合从小到大的规则
//也发生了自动类型转换。
double num2 = 2.5F;
System.out.println(num2);//2.5

//左边是floa类型，右边是long类型
//long--》float，范围是float更大一些。符合从小到大的规则
//也发生了自动类型转换。
float num3 = 30L;
System.out.println(num3);
}

}

 

 

2_3
数据类型转换-注意事项

 

/*
强制类型转换
1.特点:代码需要进行特殊格式处理,不能自动完成.
2.格式:范围小的类型 范围小的变量 = (范围小的类型) 原本范围大的数据;

注意事项:
1.强制类型转换一般不推荐使用,因为有可能发生精度损失.数据溢出.
2.byte/short/char这三种类型都可以发生数学运算,例加法"+"
3.byte/short/char这三种类型在运算的时候,都会首先提升成为int类型,然后再计算
4.boolean类型不能发生数据类型转换
*/
public class Demo02DataType{
public static void main(String [] args){
//左边是int类型,右边是long类型,不一样
//long-->int,不是从小到大
//不能发生自动类型转换
//格式:范围小的类型 范围小的变量 = (范围小的类型) 原本范围大的数据;
int num = (int)100L;
System.out.println(num);
//long 强制转换称为int类型.
int num2 = (int)6000000000L;
System.out.println(num2);//1705032704

//double -->int,强制类型转换
int num3 = (int) 3.5;
System.out.println(num3);//3 不是四舍五入 所有小数位都会被舍弃掉


char zifu1 = 'A'; //这是一个字符型变量,里面是大写字母A
System.out.println(zifu1+1);//66,也就是大写字母A被当成65处理
//计算机底层会用一个数字(二进制)来代表字符A,就是65
//一旦 char类型进行了数学计算,那么字就会按照一定的规则翻译成为一个数字

byte num4 = 40; //注意:右侧的数值大小不能超过左边的类型范围
byte num5 = 50;
//byte + byte --> int + int --> int
int result1 = num4+num5;
System.out.println (result1);//90

short num6 = 60;
//byte + short --> int + int -- > int
//int强制转换为short:注意:必须保证逻辑上真实大小本来就没有超过short范围,否则会数据溢出.
short result2 = (short) (num4 + num6);
System.out.println(result2);//100
}

}

 

 

02.04
ASCLL码表

 

// ASCLL码表

/*
数字和字符关系的对照关系表(编码表):

ASCII码表:American Standard Code for Information Interchange 美国信息交换标准代码.
Unicode码表:万国码.也是数字和符号的对照关系,开头0-127的部分和ASCII完全一样,但是从128开始包含有更多的字符.

48-'0'
65-'A'
97-'a'
*/
public class Demo03DataTypeChar {
public static void main (String [] args){
char zifu1 = '1';
System.out.println(zifu1 + 0);//49

char zifu2 = 'A'; //其实底层保存的是65数字

char zifu3 = 'c';
//左侧是int类型,右边是char类型
//char --> int,确实是从小到大
//发生了自动类型转换
int num = zifu3;
System.out.println(num);//99

char zifu4 = '中';//正确写法
System.out.println(zifu4 + 0);// 20013
}

}

 

第6节
运算符

 

 

-----02.05
算数运算符-四则与取模运算

 

 

/*
运算符:进行特定操作的符号,例如:+
表达式:用运算符连的式子叫做表达式,例:20+5.又例:a+b

四则运算:
加: +
减: -
乘: *
除: /

取模:(取余数): %

首先计算的到表达式的结果,然后再打印输出这个结果.

被除数 / 除数 = 商 ... 余数

对于一个整数的表达式来说,除法用的是整数,整数除以整数,结果仍然是整数,只看商,不看余数.
只有对于整数的除法来,取模运算才有余数的意义.

注意事项:
1.一旦运算中有不同类型的数据,那么结果将会是数据类型范围大的那种.
*/
public class Demo04Operator{
public static void main (String[]args){
//两个常量之间可以进行数字运算
System.out.println(20+30);

//两个变量之间也可以进行数学运算
int a = 20;
int b = 30;
System.out.println( a - b);// - 10

//变量和常量之间可以混合使用
System.out.println(a * 10);//200

int x = 10;
int y = 3;

int result1 = x / y;
System.out.println(result1);// 3

int result2 = x % y;
System.out.println(result2);//余数,模,1

//int + double -->
double result3 = x + 2.5;
System.out.println(result3);//12.5
}

}

 

2.06
算数运算符

 

 

/*
四则运算当中的加号"+"有长有的三种用法:

1.对于数值来,那就是加法.
2.对于字符char类型来,在计算之前,char会被提升成为int,然后再计算.
char类型字符,和int类型数字,之间的对照关系表:ASCII,UnicodeClassMapping
3.对于字符串String(首字母大写,并不是关键字)来,加号代表字符串连操作.
任何数据类型和字符串进行连接的时候,都会变成字符串
*/
public class Demo05plus {
public static void main (String [] args){
// 字符串类型的变量基本使用
//数据类型 变量名称 = 数据值;
String str1 = "hello";
System.out.println(str1);//hello

System.out.println("hello"+"world");//helloworld

String str2 = "java";
//String + int -->
System.out.println(str2+20);//java20

//优先级问题
//String + int + int
//String + int
//String
System.out.println(str2 + 20 + 30);// java2030

System.out.println(str2 + (20 + 30));//java 50

}

}

 

2.07
算数运算符-自增自减运算符

 

 

/*
自增运算符:++
自减运算符:--

基本含义:让一个变量涨一个数字1,或者让一个变量降一个数字1
使用格式:卸载变量名称之前,或者写在变量名称之后.例: ++num num++
使用方式:
1.单独使用:不和其他任何操作混合,自己独立成为一个步骤.
2.混合使用:和其他操作混合,例如与赋值混合,或者与打印混合操作,等.
使用区别:
1.在单独使用的时候,前++和后++没有任何区别.也就是: ++num;和num++;是完全一样的.
2.在混合的时候,有(重大区别)
A.如果是(前++),那么变量(立刻马上+1),然后拿着结果进行使用.(先加后用)
B.如果是(后++),那么首先使用变量本来的数值,(然后再让变量+1).(先用后加)

注意事项:
只有变量才能使用自增/自减运算符.常量不可发生改变,所以不能使用.
*/
public class Demo06Operator{
public static void main(String[] args){
int num1 = 10;
System.out.println(num1); //10
++num1; //单独使用,前++
System.out.println(num1);//11
num1++; //单独使用,后++
System.out.println(num1);//12
System.out.println("===============================");

//与打印操作混合的时候
int num2 = 20;
//混合使用,先++,变量立刻马上变成21,然后打印结果21
System.out.println(++num2);//21
System.out.println(num2);//21
System.out.println("====================");

int num3 = 30;
//混合使用,后++,首先使用变量本来的30,然后再让变量+1 得到31
System.out.println(num3++);//30
System.out.println(num3);//31
System.out.println("=====================");

int num4 = 40;
//和赋值操作混合
int result1 = --num4; //混合使用,前--,变量立刻马上-1变成39,然后将结果39交给result1变量
System.out.println(result1);//39
System.out.println(num4); //39
System.out.println("=====================");

int num5 = 50;
//混合使用,后--,首先把本来的数字50交给result2,然后自己-1变成49
int result2 = num5--;
System.out.println(result2); //50
System.out.println(num5);//49
System.out.println("=====================");

int x = 10;
int y = 20;
// 11 + 20 = 31
int result3 = ++x + y--;
System.out.println(result3);//31
System.out.println(x);//11
System.out.println(y);//19
// = 11 + 20 result3 = 31 后-- 先交给result3 然后-1
}

}

 

 

2.08
赋值运算符

 

 

/*
赋值运算符分为:

基本赋值运算符:就是一个等号"=",代表将右侧的数据交给左侧的变量.
int a = 30;

复合赋值运算符:
+= a+=1 相当于 a = a + 1
-= b-=4 相当于 b = b - 4
/= c/=6 相当于 c = c / 6
%= d%=5 相当于 d = d % 5
*= e*=3 相当于 e = e * 3

注意事项:
1.只有变量才能使用赋值运算符,常量不能进行赋值.
2.符合赋值运算符其中隐含了一个强制类型转换.

*/
public class Demo07Operator{
public static void main(String [] args){
int a = 10;
a+=1;
System.out.println(a);//11

int d = 10;
d%=3;
System.out.println(d);//1


//常量不能进行赋值,不能写在赋值运算符的左边.

byte num = 30;
//num = num + 5;
//byte + int
//复合赋值运算符会强制类型转换
//int + int
num+=5;
System.out.println(num);
}

}

 

2.09
比较运算符

 

 

/*
比较运算符:
大于: >
小于: <
大于等于: >=
小于等于: <=
相等: == [两等号连才是相等,一个等号代表的是赋值]
不相等: !=

注意事项:
1.比较运算符的结果一定是一个boolean值,成立就是true,不成立就是false
2.如果进行多次判断,不能连着写
数学当中的写法,例如:1 < x < 3
程序当中[不允许]这种写法.
*/
public class Demo08Operator{
public static void main(String[] args){
System.out.println(10 > 5);//true
int num1 = 10;
int num2 = 12;
System.out.println(num1 < num2);//true
System.out.println(num2 >= 100);//false
System.out.println(num2 <= 100);//true
System.out.println(num2 <= 12);//true
System.out.println("=======================");

System.out.println(10 == 10);//true
System.out.println(20 != 25);//true
System.out.println(20 != 20);//false

//System.out.println(1 < x < 3); 不能连着写
}

}

 

2.10
逻辑运算符

 

 

/*
与(并且) && 全都是true,才是true;否则就是false
或(或者) || 至少一个是true,就是true;全都是false,才是false
非(取反) ! 本来true,变成false;本来false,变成true

与"&&",或"||",具有短路效果:如果根据左边已经可以判断得到最终结果,那么右边的代码将不再执行,从而节省一定的性能

注意事项:
1.逻辑运算符只能用于boolean值.
2.与/或需要左右各自有一个Boolean值,但是取反只要有唯一的一个Boolean值即可.
3.与.两运算符,如果有多个条件,可以连续写.
两个条件:条件A && 条件B
多个条件:条件A && 条件B && 条件C

TIPS:
对于1 < x < 3的情况,应该拆成两个部分,然后使用与运算符连接起来:
int x = 2;
1 < x && x < 3
*/
public class Demo09Logic{
public static void main(String[]args){
System.out.println(true && false);//false
System.out.println(3 < 4 && 10 > 5);//true

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

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

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

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

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

int a = 10;
//false && ...
System.out.println(3 > 4 && ++a < 100);//false
System.out.println(a);//10

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

int b = 20;
System.out.println(3 < 4 || ++b < 100);//true
System.out.println(b);//20
}

}

 

2.11
三元运算符

 

流程:
首先判断条件是否成立:
如果成立为true,那么将表达式A的值赋值给左侧的变量;
如果不成立为false,那么将表达式B的值赋值给左侧的变量;
二者选其一.

注意事项:
1.必须同时保证表达式A和表达式B都符合左侧数据类型的要求.
2.三元运算符的结果必须被使用.
*/
public class Demo10Operator{
public static void main(String[]args){
int a = 10;
int b = 20;

//数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B;
//判断 a > b 是否成立,如果成立将a的值赋值给max;如果不成立将b的值赋值给max.二者选其一 ?前面是条件 结果为true 把 : 左边的值赋值 结果为false 把 : 右边的值赋值
int max = a > b ? a : b ; //最大值的变量
System.out.println("最大值:"+ max);//20

//int result = 3 > 4 ? 2.5 : 10;//错误写法

System.out.println(a > b ? a : b);//正确写法

//a > b ? a : b; //错误写法
}

}

 

第7节
方法入门

 

 

2.12
方法入门-概念引入

 

 

public class Demo11Method{
public static void main (String[] args){
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("卖给厨子");

System.out.println("洗菜");
System.out.println("切菜");
System.out.println("炒菜");
System.out.println("装盘");
System.out.println("吃");
}

}

 

 

2_13
方法入门-方法的定义

 

 

/*
定义一个方法格式:

public static void 方法名称(){
方法体
}

方法名称的命名规则和变量一样，使用小驼峰
方法体：也就是大括号当中可以包含任意条语句。

注意事项:
1.方法定义的先后顺序无所谓
2.方法的定义不能产生嵌套包含关系.
3.方法定义好了之后,不会执行,如果要指向,一定要进行方法的(调用).
*/
public class Demo11Method{
public static void main (String[] args){





}
//我
public static void me(){

System.out.println("吃");
}



//厨子
public static void cook(){
System.out.println("洗菜");
System.out.println("切菜");
System.out.println("炒菜");
System.out.println("装盘");

}

//商贩
public static void seller(){
System.out.println("运输到市场");
System.out.println("抬高价格");
System.out.println("吆喝");
System.out.println("卖给厨子");
}

//龙鸣
public static void farmer(){
System.out.println("播种");
System.out.println("浇水");
System.out.println("施肥");
System.out.println("除虫");
System.out.println("收割");
System.out.println("卖给小商贩");

}
}

 

 

2.14
方法入门-方法的调用

 

/*
定义一个方法格式:

public static void 方法名称(){
方法体
}

方法名称的命名规则和变量一样，使用小驼峰
方法体：也就是大括号当中可以包含任意条语句。

注意事项:
1.方法定义的先后顺序无所谓
2.方法的定义不能产生嵌套包含关系.
3.方法定义好了之后,不会执行,如果要指向,一定要进行方法的(调用).

如何调用方法.格式:

方法名称();
*/
public class Demo11Method{
public static void main (String[] args){
//调用龙鸣的方法
farmer();
//调用小商贩的方法
seller();
//调用厨子的方法
cook();
//调用我的方法
me();
}
//我
public static void me(){

System.out.println("吃");
}



//厨子
public static void cook(){
System.out.println("洗菜");
System.out.println("切菜");
System.out.println("炒菜");
System.out.println("装盘");

}

//商贩
public static void seller(){
System.out.println("运输到市场");
System.out.println("抬高价格");
System.out.println("吆喝");
System.out.println("卖给厨子");
}

//龙鸣
public static void farmer(){
System.out.println("播种");
System.out.println("浇水");
System.out.println("施肥");
System.out.println("除虫");
System.out.println("收割");
System.out.println("卖给小商贩");

}
}

 

第8节
JDK9新特性 - Jshell

 

 

2.15
JDK9的Jshell简单实用

 

 

编写代码非常少 不愿意编译和运行的时候

Dos命令行直接输入 Jshell
退出 /exit

 

2.16
编译器的两点优化

 

1.

/*
对于byte/short/char三种类型来说,如果右侧赋值的数值没有超过范围,
那么javac编译器将会自动隐含的为我们补上一个(byte)(short)(char),

1.如果没有超过左侧的范围,编译器补上强转.
2.如果右侧超过了左侧范围,那么直接编译器报错.
*/
public class Demo12Notice{
public static void main(String [] args){
//右侧确实是一个int数字,但是没有超过左侧的范围,就是正确的.
//int --> byte,不是自动类型转换
byte num1 = /*(byte)*/30;//右侧没有超过左侧的范围
System.out.println(num1);//30

//byte num2 = 128;//右侧超过了左侧的范围

//int --> vhar,没有超过范围
//编译器将会自动补上一个隐含的(char)
char zifu = /*(char)*/65;
System.out.println(zifu);//A
}

}

 

2.

 

/*
在给变量进行赋值 的时候,如果右侧的表达式当中全都是常量,没有任何变量,
那么编译器javac将会直接将若干个常量表达式计算得到结果.
short result = 5 + 8; //全都是常量,没有任何变量参与运算
编译之后,得到的.class字节码文件当中相当于[直接就是]:
shot result = 13;
右侧的常量结果数值,没有超过左侧范围,所以正确.

这称为"编译器的常量优化".

但是注意:一旦表达式当中有变量参与,那么就不能进行这种优化了.
*/
public class Demo13Notice{
public static void main (String [] args){
short num1 = 10;//正确写法,右侧没有超过左侧的范围,

short a = 5;
short b = 2;
//short + short --> int + int -- >int
//short result = a + b;//错误写法!左侧需要是int

//右侧不用变量,而是采用常量,而且只有两个常量,没有别人
short result = 5 + 8;
System.out.println(result);//13

short result = 5 + a + 8;//18 错误写法 带变量
}

}

 

第9节
选择结构-if语句-swith语句

 

3.01
流畅概述与顺序结构

 

 

1.顺序结构
2.判断结构
3.循环结构

//顺序结构
public class Demo01Sequence{
public static void main(String [] args){
System.out.println("1");
System.out.println("2");
System.out.println("3");
}

}

 

3.02
选择结构-单if语句

 

 

if 条件判断 false 不执行语句体 true 执行语句体

// age >= 18 true 执行语句体 打印输出 false 不执行语句体
//单if语句
public class Demo02if{
public static void main(String[]args){
System.out.println("今天天气不错,正在轧马路..突然发现一个地方.网吧");
int age = 19;
if (age >= 18){
System.out.println("进入网吧");
System.out.println("遇到一群猪队友 口臭");
System.out.println("回家");
}
System.out.println("回家");
}

}

 

3.03
选择结构-标准if-else语句

 

if 条件判断 true 执行语句体1 false 执行语句体2

//标准的if else语句
public class Demo03ifelse{
public static void main(String[]args){
int num = 13;

if (num % 2 == 0){//余数为0,是偶数
System.out.println("偶数");

}else{
System.out.println("奇数");

}
}

}

 

3.04
选择结构-扩展if-else语句

 

//x和y的关系满足如下:
//如果x >= 3,那么y = 2x + 1;
//如果-1 < x <3,那么y = 2x -1;
public class Demo04ifelseExt{
public static void main(String [] args){
int x = 10;
int y;
if(x >= 3){
y = 2 * x + 1;
} else if ( -1 < x && x < 3){
y = 2 * x;
}else{
y = 2 * x -1;

}
System.out.println("结果是: " + y);
}


}

 

 

3.05
联系用if语句实现考试成绩划分

 

public class Demo05IfElsePrsctise{
public static void main (String [] args){
int score = 98;
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 if(score < 60 && score >= 0){
System.out.println("不及格");
}else {//单独处理不合理的情况
System.out.println("数据错误");

}

}
}

 

 

3.06
联系用if语句替换三元运算符

 

 

//题目:使用三元运算符和标准的if-else语句分别实现:取两个数字当中的最大值
public class Demo06Max{
public static void main(String [] args) {
int a = 10;
int b = 20;

//使用三元运算符
//int max = a > b ? a : b;

//使用if语句
int max;
if (a > b){
max = a;
}else{
max = b;
}

System.out.println("最大值:" + max);
}
}

 

3.07
选择结构-标准的swith语句

 

表达式
值1 值2 值n default

语句体1 语句体2 语句体n 语句体n+1

break break break [break]
其他语句

 

public class Demo07Switch{
public static void main(String [] args){
int num = 1;

switch (num){
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("数据不合理");
break;//最后一个break语句可以省略,但是强烈推荐不要省略
}
}
}

 

 

3.08
选择结构-穿透的swith语句

 

/*
Switch语句使用的注意事项:

1.多个case后面的数值不可以重复.
2.switch后面小括号当中只能是下列数据类型:
基本数据类型:byte/short/char/int
引用数据类型:String字符串,enum枚举

3.switch语句格式可以很灵活:前后顺序可以颠倒,而且break语句还可以省略.
"匹配哪一个case就从哪一个位置向下执行, 直到遇到了break或者整体结束为止."
*/
public class Demo08SwitchNotice{
public static void main(String [] args){
int num = 1;
switch (num) {
case 1:
System.out.println("你好");
break;
case 2:
System.out.println("我好");
break;
case 3:
System.out.println("大家好");
break;
default:
System.out.println("他好,我也好");
break;
}

}
}

 

 

第10节 循环结构 - for - while -do。while

 

3.09
循环结构-循环概述与基本组成部分

 

 

for(初始化表达式①; 布尔表达式②; 步进表达式④){
循环体③
}
执行流程:①②③④>②③④>②③④....②不满足为止

①负责完成循环变量的初始化
②负责判断是否满足循环条件,不满足则跳出循环
③具体执行的语句
④循环后,循环条件所涉及变量的变化情况

 

3.10
循环结构-for循环

 

/*
循环结构的基本组成部分一般可以分成四部分:

1.初始化语句,在循环开始最初执行,而且只执行一次.
2.条件判断:如果成立:如果成立,则循环继续:如果不成立,则循环退出.
3.循环体:重复要做的事情内容,若干行语句.
4.步进语句:每次循环最后都要进行扫尾工作.没 每次循环结束之后都要执行一次.
*/
public class Demo09For{
public static void main(String [] args){
for(int a = 1;a < 100;a++;){
System.out.println(a);
}
System.out.println("程序停止")
}
}

 

3.11
循环结构-while循环

 

 

/*
while循环有一个标准格式,还有一个扩展格式

标准格式:
while (条件判读){
循环体
}

扩展格式:
初始化语句;
while(条件判断){
循环体;
步进语句;
}

*/
public class Demo10While {
public static void main(String [] args){
for(int i = 1; i <= 10; i++){
System.out.println("我错了!" + i);
}
System.out.println("==============================");

int i = 1;//1.初始化语句
while(i <=10) {//2.条件判断
System.out.println("我错了" + i);//3.循环体
i++;//步进语句

}
}
}

 

 

3.12
循环结构 do-while循环

 

初始化语句
↑→→ 循环体语句
↑ 控制条件语句
←true 判断条件语句
false
↓
其他语句

/*
do while循环的标准格式:

do{
循环体
}while(条件判断);

扩展格式:

初始化语句
do{
循环体
步进语句
}while(条件判断);
*/
public class Demo11DoWhile{
public static void main(String [] args){
for(int i = 1; i <= 10; i++){
System.out.println("我错了" + i);
}
System.out.println("=========================");

int i = 1;//1.初始化语句
do{
System.out.println("我错了" + i);
i++;
}while(i <= 10);//2.条件判断
}
}

 

03.13
练习-用循环求出1 -100之间的偶数和

 

 

/*
求 1 - 100 之间的偶数和

1.从 1 - 100 一个一个进行检查
2.必须是偶数才能使用,判断(if语句)偶数:num % 2 == 0
3.需要一个变量,用来进行累加操作.
*/
public class Demo12HundredSum{
public static void main(String [] args){
int sum = 0;//容器

for(int i = 1; i <= 100; i++){
if(i % 2 == 0 ){//如果是偶数
sum += i;
}
}
System.out.println("结果是:" + sum);//2550
}
}

 

3.14
三种循环的区别

 

/*
三种循环的区别：
1.如果条件判断从来没有满足过，那么for循环和while循环会执行0次,但是do-while循环会至少一次.
2.for循环的变量在小括号当中定义,只有循环内部才可以使用.while循环和do-while循环初始化语句本来就在外面,所以出来循环之后还可以继续使用.
*/
public class Demo13LoopDifference{
public static void main(String [] args){
for(int i = 1; i < 0; i++){
System.out.println("Hello");
}
//System.out.pintln(i)//这一行是错误写法! 因为变量i定义在for循环小括号内,只有for循环自己才能用.
System.out.println("=================")

int i = 1;
do{
System.out.println("world");
i++;
}while(i < 0);
//现在已经超出了do-while循环的范围,我们仍然可以使用变量i
System.out.println(i);//2
}
}

 

3.15
循环控制-break语句

 

/*
break关键字的用法有常见的两种:

1.用在switch语句当中,一旦执行,整个switch语句立刻结束.
2.用在循环语句当中,一旦执行,整个循环语句立刻结束,打断循环.

次数确定的场景多用for循环,否则多用while循环.
*/
public class Demo14Break{
public static void main(String [] args){
for (int i = 1; i <= 10; i++){
//从第四次开始,后面都不要,打断循环
if(i == 4){//如果当前为第四次
break;//打断循环
}
System.out.println("Hello" + i);
}
}
}

 

3.16
循环控制-continue语句

 

/*
另一种循环控制语句是continue关键字
一旦执行,立刻跳过当前次循环剩余内容,马上开始下一次循环.
*/
public class Demo15Continue{
public static void main(String [] args){
for(int i = 1; i <= 10; i++){
if(i == 4){//如果当前是第4层
continue;//跳过第四层
}
System.out.println(i + "层到了");
}
}
}

 

3.17
死循环

 

/*
永远停不下来的循环:死循环

死循环的标准格式:
while(true){
循环体
}
*/
public class Demo16DeadLoop{
public static void main(String [] args){
for(int i = 11;i >= 10;i++){
System.out.println("Hello" + i);
}
//System.out.println("1") 死循环外指令不会执行
}
}

 

3.18
嵌套循环

 

 

嵌套循环是指一个循环的循环体是另一个循环.比如for循环里面还有一个for循环,就是嵌套循环.总共的循环次数=外循环次数*内循环次数

嵌套循环格式:
for(初始化表达式;循环条件;步进表达式){
for(初始化表达式;循环条件;步进表达式){

}
}

练习:

public class Demo17LoopHourAndMinute{
public static void main(String [] args){
for(int hour = 0; hour < 24;hour++){//外层控制时
for(int minute = 0; minute < 60; minute++){//内层控制分
System.out.println(hour+"时"+minute+"分");
}
}
}
}

 

4.06
IDEA常用快捷键

 

Alt + Enter 导入包,自动修正代码
Ctrl+Y 删除光标所在行
Ctrl+D 复制光标所在行的内容,插入光标位置下面
Ctrl+Alt+L 格式化代码
Ctrl+/ 单行注释,再按取消注释
Ctrl+Shift+/ 选中代码注释,多行注释,再按取消注释
Alt+Ins 自动生成代码,toString,get,set等办法
Alt+Shift+上下箭头 溢出当前代码行

 

4.08
简单方法的使用

 

psvm IDEA main方法
5.fori IDEA 定义i 循环5次 for循环

 

/*
复习此前学习的方法基础入门知识

定义格式:
public static void 方法名称(){
方法体
}

调用格式:
方法名称()

注意事项:
1.方法定义先后顺序无所谓
2.方法定义必须是挨着的,不能在一个方法的内部定义另一个方法
3.方法定义之后不会执行,如果需要执行,一定要进行方法的调用
*/
public class Demo01Method {
public static void main(String[] args) {
printMethod();
}
public static void printMethod(){
for (int j = 0; j < 5; j++) {
for (int i= 0; i < 20; i++) {
System.out.print("*");
}
System.out.println();
}
}
}

 

4.09
方法的定义格式

 

/*
方法就是若干语句的功能集合.

方法好比一个工厂

参数(原料):进入方法的数据.
返回值(产出物):方法中出来的数据

定义方法的完整格式:
修饰符 返回值类型 方法名称(参数类型 参数名称,.....){
方法体
return 返回值;
}

修饰符:现阶段固定写法, public static
返回值类型:方法最终产生的结果类型
方法名称:方法的名字,规则和变量一样,小驼峰
参数类型:进入方法的数据类型
参数名称:进入方法数据的对应变量名称
PS:参数如果有多个,使用逗号进行分隔
方法体:方法需要做的事情,若干行代码
return:两个作用,第一停止当前方法,第二将后面的结果数据值还给调用处
返回值:方法执行后最终产生的数据结果

注意:return后面的"返回值",必须和方法名称前面的返回值类型,保持对应

定义一个int数字相加的方法.三要素:
返回值类型:int
方法名称:sum
参数列表:int a,int b
*/
public class Demo02MethodDefine {
public static void main(String[] args) {

}
public static int sum(int a,int b){
int result = a + b;
return result;
}
}

//方法没调用 无法运行 下一篇调用

 

4.10
方法的三种调用格式

 

 

/*
方法就是若干语句的功能集合.

方法好比一个工厂

参数(原料):进入方法的数据.
返回值(产出物):方法中出来的数据

定义方法的完整格式:
修饰符 返回值类型 方法名称(参数类型 参数名称,.....){
方法体
return 返回值;
}

修饰符:现阶段固定写法, public static
返回值类型:方法最终产生的结果类型
方法名称:方法的名字,规则和变量一样,小驼峰
参数类型:进入方法的数据类型
参数名称:进入方法数据的对应变量名称
PS:参数如果有多个,使用逗号进行分隔
方法体:方法需要做的事情,若干行代码
return:两个作用,第一停止当前方法,第二将后面的结果数据值还给调用处
返回值:方法执行后最终产生的数据结果

注意:return后面的"返回值",必须和方法名称前面的返回值类型,保持对应

定义一个int数字相加的方法.三要素:
返回值类型:int
方法名称:sum
参数列表:int a,int b

方法的三种调用格式:
1.单独调用:方法名称(参数);
2.打印调用:System.out.println(方法名称(参数));
3.赋值调用:数据类型 变量名称 = 方法名称(参数);

注意:此前学习的方法,返回值类型固定写为void,这种方法只能够单独调用,不能进行打印调用或赋值调用.
*/
public class Demo02MethodDefine {
public static void main(String[] args) {
//单独调用
sum(10,20);
System.out.println("==============================");

//打印调用
System.out.println(sum(10,20));//30
System.out.println("==============================");

//赋值调用
int number = sum(15, 25);
System.out.println("变量的值"+number);
}
public static int sum(int a,int b){
System.out.println("方法执行成功");
int result = a + b;
return result;
}
}

 

 

4.11
方法的调用流程图解
图解

 

4.12
对比有参数和无参数

 

package cn.itast.day04.demo02;
/*
有参数:小括号当中有内容,当一个方法需要一个数据条件,才能完成任务的时候,就是有参数.
例如两个数字相加,必须知道两个数字是多少才能相加.

无参数:小括号中留空,一个方法不需要任何数据条件,自己就能完成任务,就是无参数.
例如定义一个方法,打印固定10次HelloWorld.
*/
public class Demo03MethodParam {
public static void main(String [] args){
method1(10,20);
System.out.println("======================");
method2();
}
//两个数字相乘,必须知道连个数字各自是多少,否则无法进行计算
//有参数
public static void method1(int a,int b){
int result = a * b;
System.out.println("结果是"+result);
}
//例如打印10次固定文本字符串
public static void method2(){
for (int i= 0; i < 10 ; ++i) {
System.out.println("Hello World" + i);
}
}
}

 

4.13
对比有返回值和无返回值

 

/*
要求:定义一个方法,求出两个数字的和.
题目变形:定义一个方法,打印出两个数字的和.
*/
public class Demo04MethonReturn {
public static void main(String[] args) {
//main方法调用
//算出结果返回给num变量
int num = getSum(10,20);
System.out.println("返回值是"+ num);
System.out.println("========================");

printSum(100,200);
System.out.println("========================");

System.out.println(getSum(2,3));//正确写法
getSum(3,5);//正确写法,但是返回值没有用到
System.out.println("========================");

//对于void没有返回值的方法,只能单独,不能打印或者赋值

}
//方法,负责两个数字相加
//有返回值int,结果返回给调用处
public static int getSum(int a, int b) {
int result = a + b;
return result;
}
//方法,负责两个数字相加
//没有返回值,不会将结果返回给任何人,自己打印输出
public static void printSum(int a,int b){
int result = a + b;
System.out.println("结果是" + result);
}
}

 

 

4.14
方法练习1
比较两个数字是否相同

 

要求:
定义一个方法,判断两个数字是否相同
*/
public class Demo01MethodSame {
public static void main (String [] args){
System.out.println(isSame(10,20));//false
System.out.println(isSame(20,20));//true
}
/*
三要素:
返回值类型: boolean
方法名称: isSame
参数列表 int a,int b
*/
public static boolean isSame(int a,int b){
/* boolean same;
if(a == b){
same = true;
}else{
same =false;
}*/
//boolean same = a == b ? true : false;
boolean same = a == b;
return same;//保证return后面是布尔值
}
}

 

4.15
方法练习2
求出1到100的累加和

 

/*
要求:
定义一个方法,求出1到100的累加和
*/
public class Demo02MethodSum {
public static void main(String [] args){
System.out.println("结果是" + getSum());
}
/*三要素:
返回值:有返回值,计算结果是int数字
方法名称:getSum
参数列表:数据范围已经确定,不需要任何条件,不需要参数
*/
public static int getSum(){
int sum = 0;
for (int i = 1;i <= 100; i++) {
sum += i;
}
return sum;
}
}

 

 

4.16
方法练习3
打印指定次数的HelloWorld

 

/*
要求:
定义一个方法,用来打印指定次数的HelloWorld
*/
public class Demo03MethodPrint {
public static void main(String [] args){
printCount(5);
}
/*
三要素:
返回值类型:只进行打印操作,没有计算,没有返回值
方法名称:printCount
参数列表:打印多少次
* */
public static void printCount(int num){
for (int i = 0;i < num; i++) {
System.out.println("Hello World" + i);
}
}
}

 

4.17
方法的注意事项

 

/*
使用方法的注意事项:
1.方法应该定义在类当中,不能定义在方法当中再定义方法,不能嵌套
2.方法定义的前后顺序无所谓
3.方法定义之后不会执行,需要调用,单独调用/打印调用/赋值调用
4.如果方法有返回值,一定要加上 "return 返回值;" ,不能没有
5.return后面的返回值数据,必须和方法的返回值类型对应起来
6.对于void没有返回值的方法,不能return后面的返回值,只能return自己
7.对于方法当中最后一行的return可以省略不写
8.一个方法当中可以有多个return语句,但是必须保证同时只有一个会被执行到
*/
public class Demo04MethodNotice {
public static void main(String [] args){

}
public static int method1(){
return 10;
}
public static void method2(){
//return 10; //错误写法,方法没有返回值,return后面就不能写返回值
return;//没有返回值,只是结束方法的执行
}
public static void method3(){
System.out.println("aaa");
//return; //最后一行的return可以省略不写
}
public static int getMax(int a,int b) {
/* int max;
if (a > b) {
max = a;
} else {
max = b;
}
return max;*/

if(a > b){
return a;
}else{
return b;
}
}
}

 

4.18
方法重载的基本使用

 

/*
对于功能相似的方法,参数列表不一样,需要记住不同的方法名称

方法的重载(Overload):多个方法名称一样,参数列表不一样
好处:只需要记住一个方法名称,就可以实现类似的多个功能
*/
public class Demo01MethodOverload {
public static void main(String [] args){
/* System.out.println(sumTwo(10,20));//30
System.out.println(sumThree(10,20,30));//60
System.out.println(sumFour(10,20,30,40));//100*/
System.out.println(sum(10,20));//两个参数
System.out.println(sum(10,20,30));//三个参数
System.out.println(sum(10,20,30,40));//四个参数
}
public static int sum(int a,int b){
System.out.println("有两个参数的方法执行");
return a + b;
}

public static int sum(int a,int b,int c){
System.out.println("有三个参数的方法执行");
return a + b +c;
}

public static int sum(int a,int b,int c,int d){
System.out.println("有四个参数的方法执行");
return a + b + c + d;
}
}

 

4.19
方法重载的注意事项

 

/*
对于功能相似的方法,参数列表不一样,需要记住不同的方法名称

方法的重载(Overload):多个方法名称一样,参数列表不一样
好处:只需要记住一个方法名称,就可以实现类似的多个功能

方法重载和下列参数相关:
1.参数的个数不同
2.参数类型不同
3.参数的多类型顺序不同

方法的重载与下列因素无关:
1.与参数的名称无关
2.与方法的返回值类型无关
3.
*/
public class Demo01MethodOverload {
public static void main(String [] args){
/* System.out.println(sumTwo(10,20));//30
System.out.println(sumThree(10,20,30));//60
System.out.println(sumFour(10,20,30,40));//100*/
System.out.println(sum(10,20));//两个参数
System.out.println(sum(10,20,30));//三个参数
System.out.println(sum(10,20,30,40));//四个参数
sum(10,20);
}
//错误写法,与参数的名称无关
/*public static int sum(int x,int y){
return x + y;
}*/
/*错误写法,与方法的返回值类型无关
public static double sum (int a,int b){
return a + b +0.0;
}*/

public static int sum(double a,int b){
return (int) (a + b);
}

public static int sum(int a,double b){
return (int)(a + b);
}

public static int sum(double a,double b){
return (int)(a + b);
}

public static int sum(int a,int b){
System.out.println("有两个参数的方法执行");
return a + b;
}

public static int sum(int a,int b,int c){
System.out.println("有三个参数的方法执行");
return a + b +c;
}

public static int sum(int a,int b,int c,int d){
System.out.println("有四个参数的方法执行");
return a + b + c + d;
}
}

 

 

4.20
重载练习1
四种不同参数类型的方法

 

/*
要求:
比较两个数据是否相等
参数类型分别为两个byte类型,两个short类型,两个int类型,两个long类型
并在main方法中进行测试
*/
public class Demo02MethodOverloadSame {
public static void main(String [] args){
byte a = 10;
byte b = 20;
System.out.println(isSame(a,b));

System.out.println(isSame((short)20,(short)20));

System.out.println(isSame(11,12));

System.out.println(isSame(10L,20L));
}
public static boolean isSame(byte a,byte b){
System.out.println("两个byte的方法参数执行");
boolean same;
if(a == b){
same = true;
}else{
same = false;
}
return same;
}

public static boolean isSame(short a,short b){
System.out.println("两个short的方法参数执行");
boolean same = a == b? true:false;
return same;
}

public static boolean isSame(int a,int b){
System.out.println("两个int的方法参数执行");
return a == b;
}

public static boolean isSame(long a,long b){
System.out.println("两个long的方法参数执行");
if(a == b){
return true;
}else{
return false;
}

}
}

 

4.21
重载练习2
判断方法的正确重载

 

4.22
重载练习3
实现重载的printl方法

 

//byte short int long float double boolean char
//String
//在调用输出语句的时候,println方法其实就是进行了多种数据类型的重载形式.
public class Demo04OverloadPrint {
public static void main(String[] args) {
myPrint(100);//int
myPrint("hello");//String
}

public static void myPrint(byte num){
System.out.println(num);
}

public static void myPrint(char zifu){
System.out.println(zifu);
}

public static void myPrint(short num){
System.out.println(num);
}

public static void myPrint(int num){
System.out.println(num);
}

public static void myPrint(double num){
System.out.println(num);
}

public static void myPrint(float num){
System.out.println(num);
}

public static void myPrint(boolean is){
System.out.println(is);
}

public static void myPrint(long num){
System.out.println(num);
}

public static void myPrint(String str){
System.out.println(str);
}
}

 

 

5.01
数组的概念

 

/*
数组:是一种容器,可以存放多个数据值.

数组的特点:
1.数组是一种引用数据类型
2.数组当中的多个数据,类型必须统一
3.数组的长度在程序运行期间不能改变
*/

public class Demo01Array {
public static void main(String[] args) {
int score1 = 100;
int score2 = 98;
int score3 = 99;
System.out.println(score3);//99
score3= 100;
System.out.println(score3);
}
}

 

 

5.02
数组的定义格式一
动态初始化

 

/*
数组:是一种容器,可以存放多个数据值.

数组的特点:
1.数组是一种引用数据类型
2.数组当中的多个数据,类型必须统一
3.数组的长度在程序运行期间不能改变

数组的初始化:
1.动态初始化:(指定长度)
2.静态初始化:(指定内容)

动态初始化数组的格式:
数据类型[] 数组名称 = new 数据类型[数组长度];

解析含义:
左侧数据类型,也就是数组中保存的数据,全都是统一类型.
左侧的中括号,代表是一个数组
左侧的数组名称,给数组取一个名字
右侧的new,代表创建数组的动作
右侧的数据类型必须和左侧的数据类型保持一致
右侧中括号长度:就是数组当中,可以保存多少数据,是一个int数字
*/

public class Demo01Array {
public static void main(String[] args) {
/*int score1 = 100;
int score2 = 98;
int score3 = 99;
System.out.println(score3);//99
score3= 100;
System.out.println(score3);*/
//创建一个数组,里面可以存放300 int数组
//格式:数据类型[] 数组名称 = new 数据类型[数组长度];
int [] arrayA = new int [300];

//创建一个数组,能存放10个double类型的数据
double [] arrayB = new double [10];

//创建一个数组,能存放5个字符串
String [] arrayC = new String [5];
}
}

 

 

5.03
数组的定义格式二
静态初始化

 

/*
动态初始化:(指定长度)在创建数组的时候,直接指定数组当中数据元素个数
静态初始化:(指定内容)在创建数组的时候,不直接指定数据个数,而是直接将具体数据内容进行指定

静态初始化基本格式:
数据类型 [] 数组名称 = new 数据类型 [] { 元素1,元素2, ...};

注意事项:
虽然静态初始化没有直接说明长度,但是根据大括号里面元素具体内容,也可以自动推算出来长度
*/

public class Demo02Array {
public static void main(String[] args) {
//直接创建一个数组,里面都是int数字,具体为 5 , 15 , 25
int [] arrayA = new int [] {5,15,25};

//创建一个数组.用来装字符串,"hello" "world" "java"
String [] arryB = new String [] {"hello" , "world" , "java"};
}
}

 

5.04
数组的定义格式三
省略的静态初始化

 

/*
使用静态初始化数组的时候,格式还可以省略一下

标准格式:
数据类型 [] 数组名称 = new 数据类型 [] { 元素1,元素2, ...};

省略格式:
数据类型 [] 数组名称 = { 元素1,元素2, ...};

注意事项:
1.静态初始化没有直接指定长度,但是仍然会自动推算得到长度.
2.静态初始化格式可以拆分成两个步骤
3.动态初始化也可以拆分成为两个步骤
4.静态初始化一旦使用省略格式,就不能拆分成两个步骤了

不确定数组当中的具体内容,用动态初始化.确定具体内容,用静态初始化
*/
public class Demo03Array {
public static void main(String[] args) {
//省略格式的静态初始化
int [] arrayA = {10,20,25};

//静态初始化格式可以拆分成两个步骤
int [] arrayB;
arrayB = new int [] {10,20,25};

//动态初始化格式也可以拆分成两个步骤
int [] arrayC;
arrayC = new int [5];
}
}

 

5.05
访问数组元素进行获取

 

/*
直接打印数组名称,得到的是数组对应的:内存地址哈希值.

二进制:0,1
十进制:0,1,2,3,4,5,6,7,8,9
十六进制:0,1,2,3,4,5,6,7,8,9,a,b,c,e,d,f

访问数组元素的格式:
数组名称[索引值]

索引值:就是一个int数字,代表数组当中元素的编号

注意:索引值从0开始,一直到"数组的长度"-1为止
*/
public class Demo04Use {
public static void main(String[] args) {
//静态初始化标准格式
int [] array = new int [] {10,20,25};

System.out.println(array);//[I@2d98a335
System.out.println(array[0]);//10
System.out.println(array[1]);//20
System.out.println(array[2]);//30

//可以将数组当中的某一个元素,赋值交给变量
int num = array[1];
System.out.println(num);//20
}
}

 

5.06
访问数组元素进行赋值

 

/*
使用动态初始化的时候,其中的元素将会自动拥有一个默认值,规则:
如果是整数类型,那么默认为0;
如果为浮点类型,那么默认为0.0;
如果为字符类型,那么默认为' \U0000';
如果是布尔类型,那么默认为false;
如果是引用类型,那么默认为null;

注意事项:
静态初始化也有默认值的过程.只不过系统自动将默认值替换成了大括号中的具体数值.
*/
public class Demo05arrayUse {
public static void main(String[] args) {
//动态初始化一个数组
int [] array = new int [3];
System.out.println(array);//内存地址哈希值

System.out.println(array[0]);//0
System.out.println(array[1]);//0
System.out.println(array[2]);//0
System.out.println("======================");

//将123赋值给数组中的1号元素
array[1] = 123;
System.out.println(array[0]);//0
System.out.println(array[1]);//123
System.out.println(array[2]);//0
}
}

 

5.07
Java中的内存划分

 

Java的内存需要划分成为5个部分:
*1.栈(Stack) : 存放的都是方法中的局部变量. *方法的运行一定要在栈当中
局部变量 : 方法的参数,或者是方法{}内部的变量
作用域:一旦超出作用域, 立刻从栈内存中消失.

*2.堆(Heap) : 凡是new出来的东西,都在堆当中.
堆内存里面东西都有一个地址值 : 16进制
堆内存里面的数据, 都有默认值, 规则:
如果是整数类型,那么默认为0
如果为浮点类型,那么默认为0.0
如果为字符类型,那么默认为' \U0000'
如果是布尔类型,那么默认为false
如果是引用类型,那么默认为null

3.方法区 (Method Area) : 存储 .class 相关信息 , 包含方法的信息.

4.本地方法栈(Native Method Stack) : 与操作系统相关

5.寄存器 (pc Register) : 与CPU相关.

 

5.08
一个数组的内存图

 

 

5.09
两个数组的内存图

 

 

5.10
两个引用指向同一个数组的内存图

 

5.11
常见问题_数组索引越界异常

 

/*
数组的索引编号从0开始,一直到"数组的长度-1"结束.

访问数组元素时,如果索引编号不存在,那么发生
数组索引越界异常
ArrayIndexOutOfBoundsException
*/
public class Demo01ArrayIndex {
public static void main(String[] args) {
int [] arrayA = {15,25,35};

System.out.println(arrayA[0]);//15
System.out.println(arrayA[1]);//25
System.out.println(arrayA[2]);//35

//错误写法
//并不存在3号元素,所以发生异常
//System.out.println(arrayA[3]);
}
}

 

 

5.12
常见问题_空指针异常

 

/*
所有引用类型变量,都可以赋值为一个null值,代表里面什么都没有.
数组必须new初始化才能使用其中的元素
如果只是赋值了一个null,没有进行new创建
那么将会
空指针异常
NullPointerException
*/
public class Demo02ArrayNull {
public static void main(String[] args) {
int [] arrayA = null;
// arrayA = new int[3];
System.out.println(arrayA[0]);
}
}

 

5.13
获取数组的长度

 

/*
如何获取数组的长度
格式:
数组名称.length
将会得到一个int数字,代表数组的长度.

数组一旦创建,程序运行期间,数组长度不可改变
*/
public class Demo03ArrayLength {
public static void main(String[] args) {
int [] arrayA = new int [3];

int [] arrayB = {10,20,30,546,53,454,1,54,1,54,4,1,541,8,135,1,5,50,1,8,4354,8,13,966};

int abc = arrayB.length;
System.out.println("arrayB数组的长度:" + abc );

int [] arrayC = new int[3];
System.out.println(arrayC.length);//3
arrayC = new int [5];
System.out.println(arrayC.length);//5
}
}

 

5.14
数组的遍历输出

 

/*
遍历数组:
对数组当中的没一个元素进行处理,默认的处理方式就是打印输出
*/
public class Demo04Array {
public static void main(String[] args) {
int[] array = {10, 20, 30, 40, 50};

System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
System.out.println(array[3]);
System.out.println(array[4]);
System.out.println("=====================");

for (int i = 0; i < 5; i++) {
System.out.println(array[i]);
}
System.out.println("=====================");

int abc = array.length;
for (int b = 0; b < abc; b++) {
System.out.println(array[b]);
}
System.out.println("=====================");
}
}

 

 

5.15
求出数组中的最值

 

/*

*/
public class Demo05ArrayMax {
public static void main(String[] args) {
int [] arrayA = new int [] {10,20,25,30};

int max = arrayA[0];

for (int i = 1; i < arrayA.length; i++) {
if(max < arrayA[i]){
max = arrayA[i];
}
}
System.out.println("最大值:" + max);
}
}

 

 

/*

*/
public class Demo06ArrayMin {
public static void main(String[] args) {
int [] arrayA = new int [] {10,20,25,30};

int max = arrayA[0];

for (int i = 1; i < arrayA.length; i++) {
if(max > arrayA[i]){
max = arrayA[i];
}
}
System.out.println("最小值:" + max);
}
}

 

5.16
数组元素反转

 

/*
数组元素的反转:
前:[1,2,3,4]
后:[4,3,2,1]

要求:不能用新数组,只能用唯一一个数组
*/
public class Demo07ArrayReverse {
public static void main(String[] args) {
int [] array = {10,20,30,40,50,60};

//遍历打印遍历输出数组
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
System.out.println("==========================");
/*
初始化语句:int min = 0 , int max = array.length - 1
条件判断:min < max
步进表达式:min++ , max--
循环体:用第三个变量倒手
*/
for(int min = 0, max = array.length - 1;min < max;min++ , max--){
int temp = array[min];
array[min] = array [max];
array[max] = temp;
}
//再次打印遍历输出数组
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}

 

5.17
数组作为方法参数
传递地址

 

/*
数组可以作为方法的参数
当调用方法的时候,像方法的小括号内进行传参,传递进去的其实是数组的地址值
*/
public class Demo01ArrayParam {
public static void main(String[] args) {
int [] array = {10,20,30,40,50};

System.out.println(array);//地址值

printArray(array);//传递进去的就是array当中保存的地址值
System.out.println("===========1============");

printArray(array);
System.out.println("===========2============");

printArray(array);
System.out.println("===========3============");
}
/*
三要素
返回值类型:只进行打印 没有结果 void
方法名称:printArray
参数列表:必须有数组
*/
public static void printArray (int [] array){
System.out.println("printArray方法收到的参数是:");
System.out.println(array);//地址值
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}

 

 

5.18
数组作为方法的返回值
返回地址

 

/*
一个方法可以有0,1多个参数,但只能有0,1个返回值,不能有多个返回值

如果一个方法产生了多个数据返回
解决:使用一个数组作为返回值类型即可

任何数据类型都能作为方法的参数类型或返回值类型
数组作为方法的返回值,其实也是返回的方法的地址值
*/
public class Demo02ArrayReturn {
public static void main(String[] args) {
int [] result = calculate(10,20,30);
System.out.println(result);
System.out.println("总和:" + result[0]);

System.out.println("平均值:" + result[1]);
}

public static int[] calculate (int a,int b,int c){
int sum = a + b + c;//总和
//两个结果都希望进行返回
int avg = sum / 3;//平均数

/*int [] array = new int[2];
array [0] = sum;//总和
array [1] = avg;//平均数
return array;*/

int [] array = {sum,avg};
System.out.println(array);
return array;
}
}

 

06.01
面向对象思想的概述

 

/*
面向过程:当需要实现一个功能的时候,每一个具体步骤都要亲力亲为.详细处理每一个细节
面向对象:当需要实现一个功能的时候,不关心具体的步骤,而是找一个已经具备该功能的人来做.
*/
public class Demo01printArray {
public static void main(String[] args) {
int[] array = {10, 20, 30, 40};
//打印格式:[10,20,30,40]
//面向过程
System.out.print("[");
for (int i = 0; i < array.length; i++) {
if (i == array.length - 1) {//如果是最后一个元素
System.out.println(array[i] + "]");
} else {//如果不是最后一个元素
System.out.print(array[i] + ",");
}
}
System.out.println("======================");
//面向对象
//找一个JDK提供好的Arrays类
//其中有一个toString方法,直接就能把想要的格式变成字符串
System.out.println(Arrays.toString(array));
}
}

 

06.02
面向对象思想的举例

 

面向过程:强调步骤
面向对象:强调对象

面向对象思想是一种更符合我们思考习惯的思想,它可以将复杂的事情简单化,并将我们从执行者变成了指挥者
面向对象的语言中,包含了三大基本特征,即封装,继承和多态.

 

06.03
类和对象的关系

 

类:是一组相关属星和行为的集合.可以看成是一类事物的模板,使用事物的属性特征和行为特征来描述该类事物

属性: 名字 体重 年龄 颜色
行为: 走 跑 叫

对象: 是一类事物的具体体现.对象是类的一个实例,必然具备该事物的属性和行为.

类是对一类事物的描述,是抽象的
对象是一类书屋的实例,是具体的
类是对象的模板,对象是类的实体

 

06.04
类的定义

 

属性: 事物的状态信息
行为: 事物能够做什么

成员变量: 对象事物的属性
成员方法: 对应事物的行为

 

/*
定义一个类,模拟"学生"事物.其中就有两个组成部分

属性(是什么):
姓名:
年龄:
行为(能做什么):
吃饭
睡觉
学习

对应到Java类中:
成员变量(属性):
String name;//姓名
int age;//年龄
成员方法(行为):
public void eat() {};//吃饭
public void sleep() {}//睡觉
public void study() {}//学习

注意事项:
1.成员变量直接定义在类中,在方法外.
2.成员方法不要写static关键字.
*/
public class Student {
//成员变量
String name;//姓名
int age;//年龄

//成员方法

public void eat() {
System.out.println("吃饭饭");
}

;//吃饭

public void sleep() {
System.out.println("睡觉觉");
}//睡觉

public void study() {
System.out.println("学习习");
}//学习
}

 

6.05
对象的创建及其使用

 

/*
通常情况下,一个类并不能直接使用,需要根据类创建一个对象才能使用.

1.导包:就是指出需要使用的类在什么位置
import 包名.类名;
import cn.itcast.day06.Demo01.Student
对于和当前类属于同一个包的情况,可以省略导包语句不写

2.创建 , 格式:
类名称 对象名 = new 类名称();
Student stu = new Student();

3.使用 , 分两种情况:
使用成员变量:对象名.成员变量名
使用成员方法:对象名.成员方法名(参数)

(想用谁 就用对象名点谁)

注意事项:
如果成员变量没有进行赋值,那么将会有一个默认值,规则和数组一样.
*/
public class Demo02Student {
public static void main(String[] args) {
//1.导包
//需要使用Student类, 位于同一包下,省略导包语句不写

//2.创建
//类名称 对象名 = new 类名称();
//根据Student类,创建了一个stu对象
Student stu = new Student();

//3.使用其中的成员变量,格式:
//对象名.成员变量名
System.out.println(stu.name);//null
System.out.println(stu.age);//0
System.out.println("==========================");
//改变对象当中的变量数值内容
//将右侧的字符串,赋值交给stu对象当中的name成员变量
stu.name = "许照龙";
stu.age = 2;

System.out.println(stu.name);
System.out.println(stu.age);
System.out.println("==========================");

//4.使用对象的成员方法, 格式:
//对象名.成员方法名()
stu.eat();
stu.sleep();
stu.study();
}
}

 

06.06
手机类练习

 

/*
定义一个类,模拟"手机"事物

属性: 品牌 . 价格 . 颜色
行为:打电话 . 发短信

对应到类当中:
成员变量(属性):
String brand; //品牌
double price;//价格
String color;//颜色
成员方法(行为)
public void call(String who){}//打电话
public void sendMessage(){}//发短信
*/
public class Phone {
//成员变量
String brand;
double price;
String color;

//成员方法
public void call(String who){
System.out.println("给" + who + "打电话");
}

public void sendMessage(){
System.out.println("发短信");
}

}

 

 

public class Demo01PhoneOne {
public static void main(String[] args) {
//根据Phone类,创建一个名为phone的对象.
Phone phone = new Phone();
System.out.println(phone.brand);
System.out.println(phone.color);
System.out.println(phone.price);
System.out.println("========================");

phone.brand = "苹果";
phone.color = "五彩斑斓的黑";
phone.price = 5435142.55555;
System.out.println(phone.brand);
System.out.println(phone.color);
System.out.println(phone.price);
System.out.println("============================");

phone.call("giao");
phone.sendMessage();
}
}

 

06.07
一个对象的内存图

 

 

06.08
两个对象共用一个方法的内存图

 

 

06.09
两个引用指向同一个对象的内存图

 

 

06.10
使用对象类型作为方法的参数
图

 

public class Demo04PhoneParam {
public static void main(String[] args) {
Phone one = new Phone();
one.brand = "天子架机";
one.price = 8869;
one.color = "伊拉克黄";

method(one);//传递进去的参数其实就是地址值
}
public static void method(Phone param){
System.out.println(param.brand);//上面一样
System.out.println(param.price);//上面一样
System.out.println(param.color);//上面一样
}
}

 

06.11
使用对象类型作为方法的返回值
图

 

/*

*/
public class Demo04PhoneReturn {
public static void main(String[] args) {
Phone two = getPhone();
System.out.println(two.color);//灰色
System.out.println(two.price);//8848
System.out.println(two.brand);//苹果
}
public static Phone getPhone(){
Phone one = new Phone();
one.color = "灰色";
one.brand = "苹果";
one.price = 8848;
return one;
}
}

 

 

06.12
成员变量和局部变量的区别

 

/*
局部变量和成员变量

*1.定义的位置不一样
局部变量:方法内部
成员变量:方法外部,直接写在类当中

*2.作用范围不一样
局部变量:只有方法中可用
成员变量:整个类都可以使用

*3.默认值不同
局部变量:没有默认值,如果想要使用,必须进行手动赋值
成员变量:如果没有赋值,会有起始值,规则和数组一样

4.内存的位置不一样
局部变量:位于栈内存
成员变量:位于堆内存

5.生命周期不一样
局部变量:随着方法进栈而诞生,随着方法出栈而消失
成员变量:随着对象创建而诞生,随着对象被回收而消失
*/
public class Demo01VariableDifference {
String name;//成员变量

public void methodA(){
int num = 20 ;//局部变量
System.out.println(num);
System.out.println(name);
}
public void methodB(int param){//方法参数是局部变量
//方法在调用的时候,必然会赋值
System.out.println(param);
int age;
//System.out.println(age);//没有赋值不能使用
//System.out.println(num);//错误写法
System.out.println(name);
}
}

 

 

06.13
面向对象三大特征之封装性

 

/*
面向对象三大特征: 封装 , 继承 , 多态.

封装性在Java中的体现:
1.方法就是一种封装
2.关键字private也是一种封装

封装就是将一些细节信息隐藏起来,对外界不可见
*/
public class Demo02Method {
public static void main(String[] args) {
int[] array = {50, 10, 20, 30};
int max = getMax(array);
System.out.println("最大值:" + max);

}

//给一个数组,还一个最大值
public static int getMax(int[] array) {
int max = array[0];
for (int i = 1; i < array.length; i++) {
if (array[i] > max) {
max = array[i];
}
}
return max;
}
}

 

 

06.14
private关键字的作用及使用

 

/*
问题描述:我们定义person的年龄时,无法阻止不合理的数值被设置进来.
解决方案:用private关键字将需要保护的成员变量进行修饰

一旦使用private进行修饰,那么本类当中仍然可以随意访问.
但是,超出了本类范围之外就不能直接访问了

间接访问private成员变量,就是定义一对 Getter / Setter 方法

必须是setXxx / getXxx 的命名规则.
对于Getter来说,不能有参数,返回值类型和成员变量对应.
对于Setter来说,不能有返回值,参数类型和成员变量对应.
*/
public class Person {
String name;//姓名
private int age;//年龄

public void show(){
System.out.println("我叫:" + name + " , 年龄:" + age);
}

//这个成员方法,专门用于向age设置数据
public void setAge(int num){
if(age < 100 && age >= 0){//如果是合理情况
age = num;
}else{
System.out.println("数据不合理!");
}

}

//这个成员方法,专门用于获取age的数据
public int getAge(){
return age;
}
}

 

public class Demo03Person {
public static void main(String[] args) {
Person person = new Person();
person.show();

person.name = "茄子";
//person.age = 50;//直接访问private内容是错误的
person.setAge(20);
person.show();
}
}

 

 

06.15
练习使用private关键字定义学生类

 

/*
对于Boolean基本类型,Getter方法一定要写成isXxx的形式,Setter规则不变.
*/
public class Student {
private String name;//姓名
private int age;//年龄
private Boolean male;//是不是男生

public void setName(String str) {
name = str;
}

public String getName() {
return name;
}

public void setAge(int num) {
age = num;
}

public int getAge() {
return age;
}

public void setMale(Boolean b) {
male = b;
}

public Boolean ismale() {
return male;
}
}

 

public class Demo04Student {
public static void main(String[] args) {
Student stu = new Student();

stu.setName("鹿晗");
stu.setAge(80);
stu.setMale(false);

System.out.println("姓名: " + stu.getName());
System.out.println("年龄: " + stu.getAge());
System.out.println("是不是男生: " + stu.ismale());
}
}

 

 

06.16
this关键字的作用

 

 

/*
当方法的局部变量和类的成员变量重名的时候,根据"就近原则",优先使用局部变量.
如果需要访问类中的成员变量,需要使用格式:
this.成员变量名

"通过谁调用的方法,谁就是this"
*/
public class Person {
String name;//名字

//参数who是对方的名字
//成员变量name是自己的名字
public void sayHello(String name){
System.out.println(name + ", 你好." + " 我是" + this.name);

System.out.println(this);
}
}

 

 

public class Demo01Person {
public static void main(String[] args) {
Person person = new Person();
//设置自己的名字
person.name = "奥利给";
person.sayHello("老八");

System.out.println(person);//地址值
}
}

 

 

06.17
构造方法

 

/*
构造方法是用来专门创建对象的方法,当我们通过new关键字来创建对象时,其实就是在调用构造方法.
格式:
public 类名称(参数类型 参数名称){
方法体
}

注意事项:
1.构造方法的名称必须和所在的类名称完全一样,大小写也要一样
2.构造方法不要写返回值类型,void也不写
3.构造方法不能return一个具体的返回值
4.如果没有编写任何构造方法,那么编译器将会默认赠送一个构造方法,没有参数,方法体什么都不做
public Student(){}
5.一旦编写了至少一个构造方法,编译器将不再赠送
6.构造方法也是可以进行重载的.
重载:方法名称相同,参数列表不同
*/
public class Student {
private String name;
private int age;

//无参数构造方法
public Student() {
System.out.println("1执行!");
}

//全参数构造方法
public Student(String name, int age) {
System.out.println("2执行!");
this.name = name;
this.age = age;
}

//Getter Setter
public void setName(String name) {
this.name = name;
}

public String getName() {
return name;
}

public void setAge(int age) {
this.age = age;
}

public int getAge() {
return age;
}
}

 

 

public class Demo02Student {
public static void main(String[] args) {
Student stu1 = new Student();//无参构造
System.out.println("=============================");

Student stu2 = new Student("老八",13);//全参构造

//如果需要改变对象当中的成员变量数据,仍然还需要使用setXxx方法
stu2.setAge(14);//改变年龄
System.out.println("姓名: " + stu2.getName() + " 年龄: " + stu2.getAge());

}
}

 

 

06.18
定义一个标准的类

 

/*
一个标准的类通常要满足四个组成部分:
1.所有的成员变量都要使用private关键字修饰
2.为每一个成员变量编写Getter/Setter方法
3.编写一个无参数的构造方法
4.编写一个全参数的构造方法

这样标准的类也叫做 Java Bean
*/
public class Student {
private String name;
private int age;

public Student(){

}

public Student(String name , int age){
this.name = name;
this.age = age;
}

public void setName(String name) {
this.name = name;
}

public String getName() {
return name;
}

public void setAge(int age) {
this.age = age;
}

public int getAge() {
return age;
}
}

 

 

public class Demo01Student {
public static void main(String[] args) {
Student stu1 = new Student();
stu1.setName("老八");
stu1.setAge(14);
System.out.println("姓名: " + stu1.getName() + " 年龄: " + stu1.getAge());
System.out.println("==========================");

Student stu2 = new Student("冬泳怪鸽", 15);
System.out.println("姓名: " + stu2.getName() + " 年龄: " + stu2.getAge());
stu2.setAge(22);
System.out.println("姓名: " + stu2.getName() + " 年龄: " + stu2.getAge());
}
}

 

 

 

 

1-3
常用API第一部分

 

 

第1节
Scanner类

 

07.01
API概述和使用步骤

 

 

API使用步骤
1.打开帮助文档.
2.点击显示,找到索引,看到输入框.
3.你要找谁?在输入框里输入,然后回车.
4.看包. java.lang下的类不需要导包,其他需要.
5.看类的解释和说明
6.学习构造方法
7.使用成员方法

 

07.02
Scanner概述及其API文档的使用

 

/*
Scanner类的功能: 可以实现键盘输入数据,到程序当中.

引用类型的一般使用步骤:
1.导包:
import 包路径.类名称;

如果需要使用的目标类,和当前类位于一个包下,可以省去导包语句

只有Java.lang包下的内容不需要导包,其他的包都需要import语句

2.创建
类名称 对象名 = new 类名称();

3.使用
对象名.成员方法名();
*/
public class Demo01Scanner {
public static void main(String[] args) {
String str = "";
}
}

 

 

07.03
Scanner的使用步骤

 

import java.util.Scanner;//1.导包
/*
Scanner类的功能: 可以实现键盘输入数据,到程序当中.

引用类型的一般使用步骤:
1.导包:
import 包路径.类名称;

如果需要使用的目标类,和当前类位于一个包下,可以省去导包语句

只有Java.lang包下的内容不需要导包,其他的包都需要import语句

2.创建
类名称 对象名 = new 类名称();

3.使用
对象名.成员方法名();

获取键盘输入的一个int数字: int num = sc nextInt();
获取键盘输入的一个字符串:String str = sc next();
*/
public class Demo01Scanner {

public static void main(String[] args) {
//2.创建
//System.in 代表从键盘输入
Scanner sc = new Scanner(System.in);

//3.获取键盘输入的int数字
int num = sc.nextInt();

System.out.println("输入的int数字是: " + num);

//4.获取键盘输入的字符串
String str = sc.next();

System.out.println("输入的字符串是: " + str);
}

}