java从零开始系统性学习完整笔记（一）

java从零开始系统性学习完整超全资源+笔记（上）

前言

学习开始日期：2022.11.2
学习截止日期：进行中
**注意：**视频是基于eclipse进行编写的，最好还是用IDEA，eclipse老旧了，但是基本知识点还是不变的，等下学完这些视频，和IEDA里面有不同的地方再进行对比补充笔记。

---

一、变量与数据类型

Java语言概述

1. java语言的跨平台原理

• 平台:指的是操作系统(Windows，Linux， Mac)
• 跨平台: Java程序可以在任意操作系统上运行，一次编写到处运行
• 原理:实现跨平台需要依赖Java的虚拟机JVM ( Java Virtual Machine）
  
  2.JRE和JDK
  JRE：java的运行环境
  JDK：java的开发工具包

联系：使用JDK开发完成java程序，交给JRE去运行。

常用DOS命令

1. 打开控制台
win+ R，然后cmd回车；或者开始-搜索-输入cmd-回车。
常见DOS命令

• d:回车盘符切换

• dir(directory):列出当 前目录下的文件以及文件夹
  

• cd (change directory)改变指定目录(进入指定目录)
  

• 进入cd目录; cd 目录名称，或者目录路径
  同上图

• 回退cd…; cd
  

• cls: (clear screen)清屏- exit:退出dos命令行
  

HelloWorld案例

1.Notepad++的使用
下载安装之后新建文件，点击上方的设置按钮——选择首选项——新建——格式：windows——语言：java——编码：ANSI。

2.HelloWorld案例编写

• 首先定义一个类
  public class 类名
• 在类定义后加上一对大括号{}
• 在大括号中间添加一个主(main)方法/函数
  public static void main(String [] args){ }
• 在主方法的大括号中间添加一行输出语句
  System.out.println(“HelloWorld”);
  完整代码：

public class HelloWorld {
	public static void main(String [] args) {
		System.out.println(“HelloWorld”);
	}
}
1
2
3
4
5

单词拼写注意问题：

---

注释

●注释概述
-用于解释说明程序的文字
●Java中注释分类
-单行注释
●格式: //注释文字
-多行注释
●格式:/注释文字/
-文档注释
●格式: /*注释文字/
●注释的作用
-解释说明程序，提高程序的阅读性

关键字

• 关键字概述
  被Java语言赋予特定含义的单词
• 关键字特点
  -组成关键字的字母全部小写
  -常用的代码编辑器，针对关键字有特殊的颜色标记，非常直观，所以我们不需要去死记硬背，在今后的学习中重要的关键字也会不断的出来。
  
  

static

https://blog.csdn.net/fengyuzhengfan/article/details/38082999

常量

常量概述:
在程序执行的过程中，其值不可以发生改变的量
常量分类
-字符串常量
用双引号括起来的内容(“HelloWorld”)
-整数常量
所有整数(12,-23)
-小数常量
所有小数(12.34)
-字符常量.
用单引号括起来的内容(a,‘A’,‘0’)
-布尔常量.
较为特有，只有true和false
空常量
null(数组部分讲解)

public class HelloWorld{
	public final static String CONSTANT = "HelloWorld";
	public final static float PI = 3.14f;
	/*主方法*/
	public static void main(String[] args){
		System.out.println(CONSTANT);
	}
1
2
3
4
5
6
7

变量

• 变量概述

  • 在程序执行的过程中，在某个范围内其值可以发生改变的量
  • 从本质上讲，变量其实是内存中的一小块区域

• 变量定义格式

  • 数据类型 变量名=初始化值;
  • 注意:格式是固定的，记住格式，以不变应万变

• 计算机存储单元
  变量是内存中的小容器，用来存储数据。那么计算机内存是怎么存储数据的呢？无论是内存还是硬盘，计算机存储设备的最小信息单元叫“位（bit）”，我们又称之为“比特位”，通常用小写的字母b表示。而计算机最小的存储单元叫“字节（byte）”，通常用大写字母B表示，字节是由连续的8个位组成。
  除了字节外还有一些常用的存储单位，大家可能比较熟悉，我们一起来看看：
  1B（字节） = 8bit
  1KB = 1024B
  1MB = 1024KB
  1GB = 1024MB
  1TB = 1024GB

数据类型

Java语言是强类型语言，对于每一种数据都给出了明确的数据类型，不同的数据类型也分配了不同的内存空间，所以它们表示的数据大小也是不一样的。

基本数据类型（4类8种）

标示符

• 作用
  给包,类,方法,变量等起名字
• 组成规则
  由字符，下划线_，美元符$组成
• 这里的字符采用的是unicode字符集，所以包括英文大小写字母，中文字符，数字字符等。
• 注意事项
  • 不能以数字开头
  • 不能是Java中的关键字

命名规则

• 基本要求
  见名知意

• 常见命名的规则

• 包 (其实就是文件夹,用于对类进行管理)
  全部小写，多级包用点隔开。
  com,cn,com.demo
  命名必须全部使用英文小写字母，禁止使用“下划线”等字符。(除常量外，Java命名 习惯中均不推荐使用下划线等字符)
  项目包命名规则: …相关项目可使用…的命名法则。

• 类

  • 一个单词首字母大写 Student,Car
  • 多个单词，每个单词首字母大写 HelloWorld。
  • 如果 Java 程序源代码里定义了一个 public 类，则该源文件的主文件名必须与该 public 类（也就是该类定义使用了 public 关键字修饰）的类名相同。
  • 如果 Java 程序源代码里没有定义任何 public 类，那么 Java 程序源程序的主文件名可以是任意的。
  • 一个 Java 源文件只定义一个类，不同的类使用不同的源文件定义。
  • Class/Qbiect. terface
    类和接口使用大驼峰命名法抽象类使用“ Abstract"做为类命名的开头Exception类命名使用“Exception” 做为类命名的结尾
    Test类使用"Test" 做为类命名的结尾。

• 变量或者方法

  • 一个单词首字母小写。 age,show()
  • 多个单词，从第二个单词开始每个单词首字母大写 maxAge,getAge()

变量的定义和使用

• 变量定义的注意事项

1. 变量未赋值,不能直接使用
2. 引出变量的第二种使用格式
3. 变量只在它所属的范围内有效。
4. 变量在哪对大括号内，变量就属于哪对大括号
5. 一行上可以定义多个变量，但是不建议

类型转换

• +是一个运算符, 我们应该能够看懂，做数据的加法。
  boolean类型不能转换为其他的数据类型
• 默认转换
  byte,short,char—int—long—float—double
  byte,short,char相互之间不转换，他们参与运算首先转换为int类型
• 强制转换
  目标类型 变量名=(目标类型)(被转换的数据);

---

二、Eclipse/IDEA基本使用与配置

1:基本使用

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
3
4
5
6
7
8
9
10
11
12

2:基本配置

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
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3:删除和导入项目

A:删除项目
	选中项目 – 右键 – 删除
	从项目区域中删除
	从硬盘上删除
B:导入项目
	在项目区域右键找到import
	找到General，展开，并找到
	Existing Projects into Workspace
	点击next,然后选择你要导入的项目
	注意：这里选择的是项目名称
1
2
3
4
5
6
7
8
9
10

创建eclipse程序如图

4.快捷键汇总

IDEA快捷键

常用快捷键：
在IntelliJ IDEA中，进行查找和替换操作的默认快捷键如下：

查找：Ctrl + F（Windows/Linux）或 Command + F（Mac）
替换：Ctrl + R（Windows/Linux）或 Command + R（Mac）
使用这些快捷键后，将弹出一个查找/替换的对话框，你可以在其中输入要查找或替换的内容，并进行相应的操作。

另外，还有其他相关的快捷键可用于加强查找和替换的功能，例如：

查找下一个：F3（Windows/Linux）或 Command + G（Mac）
查找上一个：Shift + F3（Windows/Linux）或 Command + Shift + G（Mac）
在文件中查找：Ctrl + Shift + F（Windows/Linux）或 Command + Shift + F（Mac）
在路径中查找：Ctrl + Shift + F（Windows/Linux）或 Command + Shift + F（Mac）

SHIFT+CTRL+ATL+U选中某个类，点击SHIFT+CTRL+ATL+U 选中这个类以及这个类的依赖的类图
       CTRL+ALT+L  =====>>格式化java代码
       Ctrl + X =====>>删除行
       Ctrl + D =====>> 复制行
       Ctrl + N =====>>查找类
       Ctrl + F =====>>查找文本
       Ctrl + J =====>>自动代码
       Ctrl + H =====>>显示类结构图
       Ctrl + Q =====>>显示注释文档
       Ctrl + P =====>>方法参数提示
       Ctrl + E =====>>最近打开的文件
       Ctrl + R =====>>替换当前文本中的代码
       Ctrl + End =====>>跳到文件结尾
       Ctrl + Home =====>>跳到文件开头
       Ctrl + Space =====>>代码提示
       Ctrl + Shift + N =====>>查找文件
       Ctrl + Shift + R =====>>項目中全局替換
       Ctrl + Alt + L =====>>格式化代码
       Ctrl + Alt + O =====>>优化导入的类和包
       Ctrl + Shift + Space =====>>自动补全代码
       Alt + Shift + C =====>>对比最近修改的代码
       Alt + Insert =====>>生成代码（如构造函数等）
       Ctrl + Alt + Space =====>>类名或接口名提示
       Alt + Enter =====>>自动导包
       Alt + left / right =====>>切换代码视图
       Ctrl + B =====>>快速打开光标处的类或方法
       Alt + Up / Down =====>>在方法间快速移动定位
       F2 或 Shift + F2 =====>>高亮错误或警告快速定位
       Ctrl + Shift + Up / Down =====>>代码向上 / 下移动
       Ctrl+E 或者 Alt+Shift+C =====>>最近更改的代码
       Ctrl + Shift + Alt + N =====>>查找类中的方法或变量
       Ctrl + Alt + left / right =====>>返回至上次浏览的位置
       Ctrl + / 或 Ctrl + Shift + / =====>>单行注释或多行注释; 取消单行或多行注释也是一样
       fori + Tab 键 =====>>快速创建 for 循环
       psvm + Tab 键 =====>>快速创建主函数
       sout + Tab 键 =====>>快速创建输出语句
       Alt + F7 键 =====>>查看方法在哪里被调用了
       Alt + F8 键 =====>>预执行语句
       Ctrl + Alt + T =====>>ry-catch 快捷键
       Alt + Insert =====>>对字段生成 get 和 set 方法
       Ctrl+ I =====>>快速实现接口中的方法
       Ctrl+ Shift + Z =====>>恢复 Ctrl +Z去掉的内容
       Ctrl+ Shift + Enter =====>>代码自动补全
       Ctrl+ Shift + Alt + T =====>>重构代码
       Shift + F6 =====>>重命名文件
       Ctrl + Alt + V =====>>提取变量
       Shift + Shift =====>>全局搜索
       Ctrl + F12 =====>>查看当前类的所有方法
       F3 =====>>前后移动到下一匹配处
       Ctrl + W =====>>按照语法自动选中代码
       ALT+ 7 =====>>查看一个类中的所有方法
 
————————————————
版权声明：本文为CSDN博主「江阿白」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43676842/article/details/100701424
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

自定义快捷键模板输入

1.使用live模板 setting-Live Template
2. psvm

public static void main(String[]args){ 

}
1
2
3

3. sout

public class User{
    public static void main(String[] args) {
    	//sout
        System.out.println();
        //soutp; 打印当前的形参
        System.out.println("args = [" + args + "]");
        //soutm; 打印当前的方法名
        System.out.println("User.main");
        //soutv; 打印当前的变量
        int num = 10;
        System.out.println("num = " + num);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

4. fori

for (int i = 0; i < ; i++) {
        
 }
1
2
3

• 自己常用的
  注释：Ctrl+/ | Ctrl+Shift+/ 前者将当前行注释掉（行首加上//） ，后者将当前选中的内容注释掉（两端打上/* … */）
  内容辅助：Alt + / 自动写代码，类似代码提示。
  方法定位：按住Ctr1+鼠标左键，可以快速定位到对应的变量、方法或者其他的类等。
  格式化：ctrl+shift+F
  或者设置保存（ctrl+S）的时候格式化
  导包： CTRL + SHIFT + O
  查找替换：CTRL+F
  get set方法：Alt+Insert （有的电脑没有insert,按键盘上的【fn】+【f12】,那么此时即可在笔记本输入insert。）
  格式化
  
• 生成get,set方法
  
  idea：右击点击Generate or 也可以用快捷键Alt+Insert

注释多行代码：ctrl+shift+/
有用的快键键整理
来自：Eclipse快捷键大全

• 编辑
  Ctrl+1 快速修复（最经典的快捷键,就不用多说了，可以解决很多问题，比如import类、try catch包围等）
  Ctrl+Shift+F 格式化当前代码
  Ctrl+Shift+M 添加类的import导入
  Ctrl+Shift+O 组织类的import导入（既有Ctrl+Shift+M的作用，又可以帮你去除没用的导入，很有用）
  Ctrl+Y 重做（与撤销Ctrl+Z相反）
  ==Alt+/ 内容辅助（帮你省了多少次键盘敲打，太常用了） ==
  Ctrl+D 删除当前行或者多行
  ==Alt+↓ 当前行和下面一行交互位置（特别实用,可以省去先剪切,再粘贴了） ==
  Alt+↑ 当前行和上面一行交互位置（同上）
  Ctrl+Alt+↓ 复制当前行到下一行（复制增加）
  Ctrl+Alt+↑ 复制当前行到上一行（复制增加）
  Shift+Enter 在当前行的下一行插入空行（这时鼠标可以在当前行的任一位置,不一定是最后）
  Ctrl+/ 注释当前行,再按则取消注释

• 选择
  Alt+Shift+↑ 选择封装元素
  Alt+Shift+← 选择上一个元素
  Alt+Shift+→ 选择下一个元素
  Shift+← 从光标处开始往左选择字符
  Shift+→ 从光标处开始往右选择字符
  Ctrl+Shift+← 选中光标左边的单词
  Ctrl+Shift+→ 选中光标又边的单词

• 移动
  Ctrl+← 光标移到左边单词的开头，相当于vim的b
  Ctrl+→ 光标移到右边单词的末尾，相当于vim的e

• 搜索
  Ctrl+K 参照选中的Word快速定位到下一个（如果没有选中word，则搜索上一次使用搜索的word）
  Ctrl+Shift+K 参照选中的Word快速定位到上一个
  Ctrl+J 正向增量查找（按下Ctrl+J后,你所输入的每个字母编辑器都提供快速匹配定位到某个单词,如果没有,则在状态栏中显示没有找到了,查一个单词时,特别实用,要退出这个模式，按escape建）
  Ctrl+Shift+J 反向增量查找（和上条相同,只不过是从后往前查）
  Ctrl+Shift+U 列出所有包含字符串的行
  Ctrl+H 打开搜索对话框
  Ctrl+G 工作区中的声明
  Ctrl+Shift+G 工作区中的引用

• 导航
  Ctrl+Shift+T 搜索类（包括工程和关联的第三jar包）
  Ctrl+Shift+R 搜索工程中的文件
  Ctrl+E 快速显示当前Editer的下拉列表（如果当前页面没有显示的用黑体表示）
  F4 打开类型层次结构
  F3 跳转到声明处
  Alt+← 前一个编辑的页面
  Alt+→ 下一个编辑的页面（当然是针对上面那条来说了）
  Ctrl+PageUp/PageDown 在编辑器中，切换已经打开的文件

• 调试
  F5 单步跳入
  F6 单步跳过
  F7 单步返回
  F8 继续
  Ctrl+Shift+D 显示变量的值
  Ctrl+Shift+B 在当前行设置或者去掉断点
  Ctrl+R 运行至行(超好用，可以节省好多的断点)

• 重构
  （一般重构的快捷键都是Alt+Shift开头的了）
  Alt+Shift+R 重命名方法名、属性或者变量名 （是我自己最爱用的一个了,尤其是变量和类的Rename,比手工方法能节省很多劳动力）
  Alt+Shift+M 把一段函数内的代码抽取成方法 （这是重构里面最常用的方法之一了,尤其是对一大堆泥团代码有用）
  Alt+Shift+C 修改函数结构（比较实用,有N个函数调用了这个方法,修改一次搞定）
  Alt+Shift+L 抽取本地变量（ 可以直接把一些魔法数字和字符串抽取成一个变量,尤其是多处调用的时候）
  Alt+Shift+F 把Class中的local变量变为field变量 （比较实用的功能）
  Alt+Shift+I 合并变量（可能这样说有点不妥Inline）
  Alt+Shift+V 移动函数和变量（不怎么常用）
  Alt+Shift+Z 重构的后悔药（Undo）

• 其他
  Alt+Enter 显示当前选择资源的属性，windows下的查看文件的属性就是这个快捷键，通常用来查看文件在windows中的实际路径
  Ctrl+↑ 文本编辑器 上滚行
  Ctrl+↓ 文本编辑器 下滚行
  Ctrl+M 最大化当前的Edit或View （再按则反之）
  Ctrl+O 快速显示 OutLine（不开Outline窗口的同学，这个快捷键是必不可少的）
  Ctrl+T 快速显示当前类的继承结构
  Ctrl+W 关闭当前Editer（windows下关闭打开的对话框也是这个，还有qq、旺旺、浏览器等都是）
  Ctrl+L 文本编辑器 转至行
  F2 显示工具提示描述

• idea与eclipse快捷键对比
  参考文章：IDEA和Eclipse的比较
  
  IDEA快捷键汇总：
  1.idea下设置main快捷键 自动输出 public static void main(String args[]){}方法
  参考：idea下设置main快捷键 自动输出 public static void main(String args[]){}方法
  查找 CTRL+ F
  文件中查找 CTRL + SHIFT + F

5.Debug

1.双击侧边栏，打断点；
2.点击运行debug as；
取消断点：
参考：eclipse如何取消断点

• 方法一：
  1.适合于在debug界面，更快速。也可以是在编辑界面切换到debug界面。2、成功进入debug界面之后，从右上角找到breakpoint选项（三个选项中的中间一个）。3、会看到一排图标，一个X号的表示取消选择的debug断点，两个X号的是取消所有断点。选择两个X号的，点击。4、弹出来的对话框，点击yes，就可以取消所有的断点了。
• 方法二：
  在javaee等编辑界面，直接使用run–>removebreakpoint。就可以取消所有的断点。

6.包里面再创建包

1.先创建java文件

2.

三、运算符和表达式

运算符

代码

package com.yunSuanFu;

public class YunSuanFu {
/**
 * Alt + / 自动写代码，类似代码提示
 */

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//加法
		int c = add(1,2);
		System.out.println(c);
		//减法
		float d = substract(3, 2);
		System.out.println(d);
		//乘法
		YunSuanFu yunsuanfu = new YunSuanFu();	//不能将静态的方法写在非静态的方法中
//		非静态的变量(动态的类）就要新建一个对象
		int e = yunsuanfu.multiply(5, 6);
		System.out.println(e);
		//除法
		float f = yunsuanfu.divide(33.3f, 3.0f);
		System.out.println(f);
		int h = yunsuanfu.divide(10, 5);
		System.out.println("整数的除法" + h);
		//取余
		long g = yunsuanfu.mod(10, 3);
		System.out.println(g);			
	}
	/** 文档注释  
	* 两个整数相加
	* @param a
	* @param b
	* return */
	public static int add(int a,int b) {
		int c = a + b;
		return c;
	}
	/** 减法*/
	public static float substract(float a,float b) {
		float c = a - b;
		return c;
	}
	/**  乘法*/
	public int multiply(int a,int b) {
		int c = a * b;
		return c;
	}
	/** 除法*/
	public float divide(float a,float b) {
		return a/b;
	}
	
	public int divide(int a,int b) {
		return a/b;
	}
	
	/** 取余*/
	public long mod(long a,long b) {
		return a % b;		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

运算符

• 对常量和变量进行操作的符号称为运算符
  表达式
• 用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。不同运算符连接的式子体现的是不同类型的表达式。
  定义两个int类型的变量a,b，做加法(a+ b)
• 常用运算符
  算术运算符
  赋值运算符
  关系运算符
  逻辑运算符
  三元运算符

算术运算符
• +,-,*,/的基本使用
%的使用
– %和/的区别
• ++,–
自增自减

• 字符和字符串参与+运算

int i = 10;
		int j = 5;
		System.out.println(++i);	//++放在前面的时候先加1再做其他运算
		System.out.println(j++);	//++放在后面的时候先调用它的值再加1
		System.out.println(j);
1
2
3
4
5

输出结果：

11
5
6
1
2
3

• 字符参与运算
– 其实是拿该字符对应的数值来操作
– ‘a’ 97
– ‘A’ 65
– ‘0’ 48

• 字符串参与运算
– 这里其实做的不是加法运算，而是字符串拼接。
– 字符串和其他类型的数据做拼接，结果是字符串类型的。

• 赋值运算符
  • 基本的赋值运算符： =
  • 扩展的赋值运算符：+=,-=,*=,/=,…
  关系运算符
  • ==,!=,>,>=,<,<=
  • 关系运算符的结果都是boolean型，也就是要么是true，要么是false。
  • 注意事项
  – 关系运算符“ ==”不能误写成“=” 。

-逻辑运算符
• 逻辑运算符用于连接布尔型表达式，在Java中不
可以写成33 && x<6 。
• &,|,^,!
• &&,||
– “&”和“&&”的区别：
• 单&时，左边无论真假，右边都进行运算；
• 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
• “|”和“||”的区别同理，双或时，左边为真，右边不参与运算。第一个左边为假判断右边第二个。

• 三元运算符
  • 格式
  – (关系表达式)?表达式1：表达式2；
  – 如果条件为true，运算后的结果是表达式1；
  – 如果条件为false，运算后的结果是表达式2；
  • 示例：
  – 获取两个数中大数。
  – int x=3,y=4,z;
  – z = (x>y)?x:y;//z变量存储的就是两个数的大数。

键盘录入

键盘录入数据概述
我们目前在写程序的时候，数据值都是固定的，但是实际开发中，数据值肯定是变化的，所以，把数据改进为键盘录入，提高程序的灵活性。
如何实现键盘录入数据呢?(目前先记住使用)

导包(位置放到class定义的上面)
import java.util.Scanner;
创建对象
Scanner sc = new Scanner(System.in);
接收数据
int x = sc.nextInt();
1
2
3
4
5
6

核心步骤：

//0.导入包
import java.util.Scanner;
// 1.创建键盘录入的对象
		Scanner sc = new Scanner(System.in);
		// 2.接收数据
		System.out.println("请输入第一个数据:");
		int a = sc.nextInt();
		System.out.println("请输入第二个数据:");
		int b = sc.nextInt();
1
2
3
4
5
6
7
8
9

练习：
键盘录入两个数据，并对这两个数据求和，输出其结果
键盘录入两个数据，获取这两个数据中的最大值
键盘录入两个数据，比较这两个数据是否相等
键盘录入三个数据，获取这三个数据中的最大值

代码：

package com.demo;

import java.util.Scanner;

/**
 * 引入包 CTRL + SHIFT + O
 */

public class ScannerDemo {
	public static void main(String[] args) {
		// 1.创建键盘录入的对象
		Scanner sc = new Scanner(System.in);
		// 2.接收数据
		System.out.println("请输入第一个数据:");
		int a = sc.nextInt();
		System.out.println("请输入第二个数据:");
		int b = sc.nextInt();
		// 对数据进行求和
		int sum = a + b;
		System.out.println("sum = " + sum);
		// 三元组运算符判断两个数是否相等
		boolean flag = ((a == b) ? true : false);
		System.out.println("flag:" + flag);
		System.out.println("请输入第三个数据:");
		int c = sc.nextInt();
		int temp = ((a > b) ? a : b);
		int max = ((temp > c) ? temp : c);
		System.out.println("max: " + max);

	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

四、条件判断与循环语句

选择结构

• if
  if语句有三种格式
  if语句第一种格式：

if(关系表达式) {
		     语句体
	}
1
2
3

执行流程
首先判断关系表达式看其结果是true还是false
如果是true就执行语句体
如果是false就不执行语句体

if语句第二种格式：

if(关系表达式) {
		     语句体1;
	}else {
		     语句体2;
	}
1
2
3
4
5

执行流程
首先判断关系表达式看其结果是true还是false
如果是true就执行语句体1
如果是false就执行语句体2

if语句第三种格式：

if(关系表达式1) {
		     语句体1;
	}else  if (关系表达式2) {
		     语句体2;
	}
    …
	else {
		     语句体n+1;
	}
1
2
3
4
5
6
7
8
9

• switch
  switch语句格式：

switch(表达式) {
	      case 值1：
			语句体1;
			break;
		    case 值2：
			语句体2;
			break;
		    …
		    default：	
			语句体n+1;
			break;
    }
1
2
3
4
5
6
7
8
9
10
11
12

格式解释
switch表示这是switch语句
表达式的取值：byte,short,int,char
JDK5以后可以是枚举
JDK7以后可以是String
case后面跟的是要和表达式进行比较的值
语句体部分可以是一条或多条语句
break表示中断，结束的意思，可以结束switch语句
default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。

循环结构

• for
  for循环语句格式：

for(初始化语句;判断条件语句;控制条件语句) {
         循环体语句;
    }
1
2
3

执行流程
A:执行初始化语句
B:执行判断条件语句，看其结果是true还是false
如果是false，循环结束。
如果是true，继续执行。
C:执行循环体语句
D:执行控制条件语句
E:回到B继续

• while
  while循环语句格式：

基本格式
   while(判断条件语句) {
         循环体语句;
   }
改版格式
   初始化语句;
   while(判断条件语句) {
         循环体语句;
         控制条件语句;
    }
1
2
3
4
5
6
7
8
9
10

• do … while
  do…while循环语句格式：
  基本格式

 do {
         循环体语句;
   }while((判断条件语句);
改版格式
   初始化语句;
   do {
         循环体语句;
         控制条件语句;
    } while((判断条件语句);
1
2
3
4
5
6
7
8
9

• for while do…while对比
  虽然可以完成同样的功能，但是还是有小区别：
  do…while循环至少会执行一次循环体。
  for循环和while循环只有在条件成立的时候才会去执行循环体
  for循环语句和while循环语句的小区别：
  使用区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。
• continue 与 break

  • continue的使用场景：
    在循环语句中
    离开使用场景的存在是没有意义的
    continue的作用：
    单层循环对比break，然后总结两个的区别
    break 退出当前循环
    continue 退出本次循环

  • break的使用场景：
    在选择结构switch语句中
    在循环语句中
    离开使用场景的存在是没有意义的
    break的作用：
    跳出单层循环

随机数

作用：
用于产生一个随机数
使用步骤(和Scanner类似)

导包
import java.util.Random;
创建对象
Random r = new Random();
获取随机数
int number = r.nextInt(10);
//10表示随机数的范围0-10
1
2
3
4
5
6
7

产生的数据在0到10之间，包括0，不包括10。

Random r = new Random();
int number = r.nextInt(10);	
1
2

如何获取一个1-100之间的随机数呢?

Random r = new Random();
int number = r.nextInt(10) + 1;	//在结果出加1，随机数是默认范围从0开始。
1
2

综合练习
猜数字小游戏案例
系统产生一个1-100之间的随机数，请猜出这个数据是多少。
分析：
A:系统产生一个1-100之间的随机数
Random r = new Random();
int number = r.nextInt(100) + 1;
B:键盘录入我们要猜的数据
C:比较这两个数据,用if语句实现
大了：提示大了
小了：提示小了
猜中了：提示恭喜你,猜中了
D:多次猜数据,而我们不知道猜多少次,怎么办呢?
==while(true) {循环体语句;}==表示一直运行。

public class RandomTest {
	public static void main(String[] args) {
		//系统产生一个1-100之间的随机数
		Random r = new Random();
		//获取随机数
		int number = r.nextInt(100) + 1;
		
		//多次猜数据
		while(true) {	//while(true)表示一直运行
			//键盘录入我们要猜的数据
			Scanner sc = new Scanner(System.in);
			//接收数据
			System.out.println("请输入你要猜的数据(1-100)：");
			int guessNumber = sc.nextInt();
			
			//比较这两个数据,用if语句实现
			if(guessNumber > number) {
				System.out.println("你猜的数据"+guessNumber+"大了");
			}else if(guessNumber < number) {
				System.out.println("你猜的数据"+guessNumber+"小了");
			}else {
				System.out.println("恭喜你,猜中了");
				break;	//跳出循环
			}
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

五、数组

一维数组&内存图解

• 数组的概念
  • 定义格式

格式1：数据类型[] 数组名;
格式2：数据类型 数组名[];
注意：这两种定义做完了，数组中是没有元素值的。
1
2
3

数组初始化概述：
Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
数组的初始化方式：
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。

格式：数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
举例：
int[] arr = new int[3];
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
举例：
int[] arr = new int[]{1,2,3};
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。
其实这种写法还有一个简化的写法
int[] arr = {1,2,3};

java中的内存分配：
Java 程序在运行时，需要在内存中分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈 存储局部变量
堆 存储new出来的东西
方法区 (面向对象进阶讲)
本地方法区 (和系统相关)
寄存器 (给CPU使用)

• 数组操作的两个常见小问题
  1.数组索引越界
  ArrayIndexOutOfBoundsException
  访问到了数组中的不存在的索引时发生。
  2.空指针异常
  NullPointerException
  数组引用没有指向对象，却在操作对象中的元素时。

• 内存图解1：
  定义一个数组，输出数组名及元素。然后给数组中的元素赋值，再次输出数组名及元素。
  

• 内存图解2：
  定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素。
  

• 内存图解3：
  定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。然后给第二个数组赋值，再次输出两个数组的名及元素。
  

• 练习
  一维数组遍历：

public class array {
	public static void main(String[] args) {
//		int[] arr = new int[6];
		int[] arr = { 2, 4, 5, 6 };
//		int array[3] = {2,4,5,6};
		for (int i = 0; i <= 3; i++) {
			System.out.println(arr[i]);
		}
	}
}
1
2
3
4
5
6
7
8
9
10

• 获取数值长度：数值名.length
• 数组获取最值(获取数组中的最大值最小值)
  先画图，然后讲解

二维数组

• 定义格式
  数据类型[][] 数组名;
  数据类型 数组名[][]; 不推荐
  数据类型[] 数组名[]; 不推荐
• 初始化方式
  数据类型[][] 变量名 = new 数据类型[m][n];
  数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
  简化版格式：数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
• 二维数组遍历
  int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};

六、方法

方法定义及格式

• 简单的说：方法就是完成特定功能的代码块
  在很多语言里面都有函数的定义
  函数在Java中被称为方法

• 格式：
  修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {
  函数体;
  return 返回值;
  }

• 方法格式解释
  修饰符 目前记住 public static
  返回值类型 用于限定返回值的数据类型
  方法名 一个名字，为了方便我们调用方法
  参数类型 用于限定调用方法时传入的数据的类型
  参数名 用于接收调用方法时传入的数据的变量
  方法体 完成功能的代码
  return 结束方法，把返回值带给调用者

• 方法案例
  写一个方法首先有两点需要明确
  返回值类型 明确功能结果的数据类型
  参数列表 明确有几个参数，以及参数的类型
  按照格式和两个明确来完成如下功能
  求两个数据之和的案例

形参和实参

参考：java形参和实参
1.形参：形参定义在方法（函数）中，只有调用所对应的函数时才会分配给形参内存单元，调用结束后释放所分配的内存单元，因此形参只可以在定义的函数内部使用。

2.实参：实参可以是变量，常量，表达式等等。从刚开始定义便有内存单元，所分配的内存单元与是否调用无关。

例如

package com.demo03;
/*
 * 方法重载：在同一个类中，出现了方法名相同的情况。
 * 方法重载的特点：
 * 		方法名相同，参数列表不同。与返回值无关。
 * 		参数列表不同：
 * 			参数的个数不同
 * 			参数对应的数据类型不同
 * 
 * 注意：
 * 		在调用方法的时候，java虚拟机会通过参数列表的不同来区分同名的方法。
 */
public class MethodDemo {
	public static void main(String[] args) {
		float c = sum(1.2f,2.3f);	//1.2f,2.3f实参
		System.out.println(c);
	}
	
	//不能出现方法名相同，并且参数列表也相同的情况
//	public static int sum(int x,int y) {	//x,y形参
//		return x + y;
//	}
	
	public static float sum(float a,float b) {
		return a + b;
	}
	
	//求三个数据的和
	/*
	public static int sum2(int a,int b,int c) {
		return a + b + c;
	}
	*/
	public static int sum(int a,int b,int c) {
		return a + b + c;
	}
	
	//求两个数据的和方法
	public static int sum(int a,int b) {
		//int c = a + b;
		//return c;
		
		return a + b;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

package com.demo04;

/*
 * 方法的参数如果是基本数据类型：形式参数的改变不影响实际参数。
 * 
 * 形式参数：用于接收实际参数的变量
 * 实际参数：实际参与运算的变量
 */
public class ArgsDemo {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		System.out.println("a:"+a+",b:"+b);//a:10,b:20
		change(a,b);
		System.out.println("a:"+a+",b:"+b);//??? a:10,b:20

	}

	public static void change(int a,int b) {//a=10,b=20
		System.out.println("a:"+a+",b:"+b);//a:10,b:20
		a = b;//a=20
		b = a + b;//b=40
		System.out.println("a:"+a+",b:"+b);//a:20,b:40
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

package com.demo04;

/*
 * 如果参数是引用数据类型：
 * 		形式参数的改变直接影响实际参数
 */
public class ArgsDemo2 {
	public static void main(String[] args) {
		int[] arr = { 1, 2, 3, 4, 5 };
		for (int x = 0; x < arr.length; x++) {
			System.out. println(arr[x]);
		}
		System.out.println("-------------------------");
		change(arr);
		for (int x = 0; x < arr.length; x++) {
			System.out.println(arr[x]);
		}
	}

	public static void change(int[] arr) {
		for (int x = 0; x < arr.length; x++) {
			if (arr[x] % 2 == 0) {
				arr[x] *= 2;
			}
		}
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

• 有明确返回值的方法调用
  单独调用，没有意义
  输出调用，有意义，但是不够好，因为我不一定非要把结果输出
  赋值调用，推荐方式

• 有明确返回值的方法练习
  键盘录入两个数据，返回两个数中的较大值
  键盘录入两个数据，比较两个数是否相等
  键盘录入三个数据，返回三个数中的最大值

• 没有明确返回值的方法定义和调用
  写一个方法，在控制台输出10次HelloWorld案例。
  没有明确返回值的函数调用：
  其实就是void类型方法的调用
  只能单独调用

• 没有明确返回值的方法练习
  写一个方法，传递一个整数(大于1)，在控制台打印1到该数据的值。
  写一个方法，把所有的水仙花数打印在控制台

方法重载

方法重载概述
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
方法重载特点
与返回值类型无关，只看方法名和参数列表
在调用时，虚拟机通过参数列表的不同来区分同名方法

• 方法重载练习
  比较两个数据是否相等。参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，并在main方法中进行测试

package com.demo03;
/*
 * 比较两个数据是否相等。参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，并在main方法中进行测试
 */
public class MethodTest {
	public static void main(String[] args) {
		//System.out.println(compare(10, 20));
		
		//System.out.println(compare((byte)10, (byte)20));
		
		//System.out.println(compare((short)10, (short)20));
		
		System.out.println(compare(10L, 20L));
	}
	
	//byte
	public static boolean compare(byte a,byte b) {
		System.out.println("byte");
		return a == b;
	}
	
	//short
	public static boolean compare(short a,short b) {
		System.out.println("short");
		return a == b;
	}
	
	//int
	public static boolean compare(int a,int b) {
		System.out.println("int");
		return a == b;
	}
	
	//long
	public static boolean compare(long a,long b) {
		System.out.println("long");
		return a == b;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

• 方法参数传递问题
  看程序写结果，并总结基本类型和引用类型参数的传递问题(代码在备注部分)

• 方法练习
  1.把遍历数组改进为方法实现，并调用方法

package fangFa;

public class printArray {
	public static void main(String[] args) {
//		int[] arr = new int[4];
		int arr2[] = { 1, 2, 3 };
		printArray2(arr2);
	}

	public static void printArray2(int[] arr) {
		System.out.print("[");
		for (int x = 0; x < arr.length; x++) {
			if (x == arr.length - 1) {
				System.out.print(arr[x] + "]");
			} else {
				System.out.print(arr[x] + ",");
			}
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2.把获取数组最值改进为方法实现，并调用方法

public class MethodTest2 {
	public static void main(String[] args) {
		//定义数组
		int[] arr = {24,36,90,75,81};
		
		/*
		//定义参照物
		int max = arr[0];
		//遍历数组,获取元素,依次比较
		for(int x=1; x<arr.length; x++) {
			if(arr[x] > max) {
				max = arr[x];
			}
		}
		*/
		//写方法实现获取数组中的最大值
		int min = getMin(arr);
		
		//输出结果
		System.out.println("min:"+min);
	}
	
	/*
	 * 两个明确：
	 * 		返回值类型：int
	 * 		参数列表：int[] arr
	 */
	public static int getMin(int[] arr) {
		//定义参照物
		int min = arr[0];
		//遍历数组,获取元素,依次比较
		for(int x=1; x<arr.length; x++) {
			if(arr[x] < min) {
				min = arr[x];
			}
		}
		return min;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

写一个方法，用于对数组进行求和，并调用方法。

package com.demo05;
/*
 * 写一个方法，用于对数组进行求和，并调用方法。
 */
public class MethodTest3 {
	public static void main(String[] args) {
		//定义数组
		int[] arr = {1,2,3,4,5};
		
		/*
		//定义求和变量
		int sum = 0;
		//获取数组中的每一个元素
		for(int x=0; x<arr.length; x++) {
			//累加
			sum += arr[x];
		}
		*/
		
		//写方法实现
		int sum = sum(arr);
		
		//输出结果
		System.out.println("sum:"+sum);
		
	}
	
	/*
	 * 两个明确：
	 * 		返回值类型：int
	 * 		参数列表：int[] arr
	 */
	public static int sum(int[] arr) {
		//定义求和变量
		int sum = 0;
		//获取数组中的每一个元素
		for(int x=0; x<arr.length; x++) {
			//累加
			sum += arr[x];
		}
		return sum;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

上半部分基础语法系统练习

题目

1. 键盘录入月份，输出对应的季节
   2. 打印5位数中所有的回文数
   3. 不死神兔问题
   4. 求数组中满足要求的元素和
   5. 裁判评分
   6. 数组反转
   7. 数组基本查找
   8. 数据加密

1. 键盘录入月份，输出对应的季节(键盘录入+循环）

package com.demo1;

/*
 * 需求：键盘录入一个月份，输出该月份对应的季节。
 * 一年有四季
 * 		3,4,5	春季
 * 		6,7,8	夏季
 * 		9,10,11	秋季
 * 		12,1,2	冬季
 * 
 * 
 * */
import java.util.Scanner;

public class jiJie {
	public static void main(String[] args) {
//		键盘录入
		Scanner sc = new Scanner(System.in);
//		接收数据
		System.out.println("键盘输入月份:");
		int month = sc.nextInt();
		while ((month >= 1) && (month <= 12)) {
			if ((month == 3) || (month == 4) || (month == 5)) {
				System.out.println("春季");
				break;
			}
			if ((month == 6) || (month == 7) || (month == 8)) {
				System.out.println("夏季");
				break;
			}
			if ((month == 9) || (month == 10) || (month == 11)) {
				System.out.println("秋季");
				break;
			}
			if ((month == 12) || (month == 1) || (month == 2)) {
				System.out.println("冬季");
				break;
			}
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

2.打印5位数中所有的回文数 (for+if训练）

package com.demo;
/*
 * 需求：打印5位数中的所有回文数。
 * 		什么是回文数呢?举例：12321是回文数，个位与万位相同，十位与千位相同。
 * 
 * 分析：
 * 		A:5位数告诉了我们数据的范围,用for循环实现
 * 		B:拿到每一个5位数后,获取其个位,十位,千位,万位的数据
 * 			如何获取呢?假设x是一个5位数
 * 			个位：x%10
 * 			十位：x/10%10
 * 			千位：x/10/10/10%10
 * 			万位：x/10/10/10/10%10
 * 		C:根据条件进行判断,把满足条件的数据输出即可
 */
public class Test3 {
	public static void main(String[] args) {
		//5位数告诉了我们数据的范围,用for循环实现
		int i = 0;
		for(int x=10000; x<100000; x++) {
			//拿到每一个5位数后,获取其个位,十位,千位,万位的数据
			int ge = x%10;
			int shi = x/10%10;
			int qian = x/10/10/10%10;
			int wan = x/10/10/10/10%10;
			
			//根据条件进行判断,把满足条件的数据输出即可
			if((ge == wan) && (shi == qian)) {
				System.out.println(x);
				i++;
			}
		}
		System.out.println(i);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

3. 不死神兔问题

package com.demo;

/*
 * 需求：
 * 		有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，
 * 		假如兔子都不死，问第二十个月的兔子对数为多少？ 
 * 
 * 规律：
 * 		第一个月：1
 * 		第二个月：1
 * 		第三个月：2
 * 		第四个月：3
 * 		第五个月：5
 * 		...
 * 
 * 		规律：从第三个月开始，每个月的兔子对数是前两个月的兔子对数之和
 *          第一个月和第二个月的兔子对数都是1
 * 
 * 分析：
 * 		A:由于数据比较多,所以我们就定义数组来实现了
 * 			int[] arr = new int[20];
 * 		B:给数组的元素赋值
 * 			arr[0] = 1
 * 			arr[1] = 2
 * 		C:找规律
 * 			arr[2] = arr[1] + arr[0];
 * 			arr[3] = arr[2] + arr[1];
 * 			arr[4] = arr[3] + arr[2];
 * 			arr[5] = arr[4] + arr[3];
 * 			...	
 */
public class Test4 {
	public static void main(String[] args) {
		//定义数组
		int[] arr = new int[20];
		
		//给数组的元素赋值
		arr[0] = 1;
		arr[1] = 1;
		
		//找规律赋值
		for(int x=2; x<arr.length; x++) {
			arr[x] = arr[x-1] + arr[x-2];
		}
		
		//输出结果
		System.out.println("第二十个月兔子的对数是："+arr[19]);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

4. 求数组中满足要求的元素和

package com.demo;

/*
 * 需求：
 * (1)定义一个int类型的一维数组，内容为{171,72,19,16,118,51,210,7,18}
 * (2)求出该数组中满足要求的元素和。
 * 		要求：求和的元素的个位和十位不能包含7,并且只能为偶数。
 * 
 * 分析：
 * 		A:定义一个int类型的一维数组
 * 		B:定义一个求和变量
 * 		C:遍历数组,获取数组中的每一个元素
 * 		D:判断该元素是否满足条件，如果满足条件就累加
 * 			假设该数据是x
 * 			个位不能是7：x%10 != 7
 * 			十位不能是7：x/10%10 != 7
 * 			必须是偶数：x%2 == 0
 * 		E:输出求和结果
 */
public class Test5 {
	public static void main(String[] args) {
		//定义一个int类型的一维数组
		int[] arr = {171,72,19,16,118,51,210,7,18};
		
		//定义一个求和变量
		int sum = 0;
		
		//遍历数组,获取数组中的每一个元素
		for(int x=0; x<arr.length; x++) {
			//判断该元素是否满足条件，如果满足条件就累加
			if((arr[x]%10 != 7) && (arr[x]/10%10 != 7) && (arr[x]%2 == 0)) {
				sum += arr[x];
			}
		}
		
		//输出求和结果
		System.out.println("sum:"+sum);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

5. 裁判评分

package com.demo;

import java.util.Scanner;

/*
 * 需求：在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
 * 选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值。
 * 请写代码实现。(不考虑小数部分)
 * 
 * 分析：
 * 		A:定义一个长度为6的数组
 * 		B:键盘录入评委的分数
 * 		C:写方法实现获取最高分,最低分
 * 		D:写方法求评委的分数和
 * 		E:平均分：(和-最高分-最低分)/(arr.length-2)
 * 		F:输出平均分即可
 */
public class Test6 {
	public static void main(String[] args) {
		//定义一个长度为6的数组
		int[] arr = new int[6];
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		//键盘录入评委的分数
		for(int x=0; x<arr.length; x++) {
			//接收数据
			System.out.println("请输入第"+(x+1)+"个评委给出的分数(0-100)：");
			int score = sc.nextInt();
			arr[x] = score;
		}
		
		//写方法实现获取最高分,最低分
		//调用方法
		int max = getMax(arr);
		int min = getMin(arr);
		
		//写方法求评委的分数和
		int sum = sum(arr);
		
		//平均分：(和-最高分-最低分)/(arr.length-2)
		int avg = (sum-max-min)/(arr.length-2);
		
		//输出平均分即可
		System.out.println("该选手的最终得分是："+avg);
	}
	
	/*
	 * 两个明确：
	 * 		返回值类型：int
	 * 		参数列表：int[] arr
	 */
	public static int sum(int[] arr) {
		//定义求和变量
		int sum = 0;
		
		for(int x=0; x<arr.length; x++) {
			sum += arr[x];
		}
		
		return sum;
	}
	
	/*
	 * 两个明确：
	 * 		返回值类型：int
	 * 		参数列表：int[] arr
	 */
	public static int getMin(int[] arr) {
		//定义参照物
		int min = arr[0];
		
		for(int x=1; x<arr.length; x++) {
			if(arr[x] < min) {
				min = arr[x];
			}
		}
		
		return min;
	}
	
	/*
	 * 两个明确：
	 * 		返回值类型：int
	 * 		参数列表：int[] arr
	 */
	public static int getMax(int[] arr) {
		//定义参照物
		int max = arr[0];
		
		for(int x=1; x<arr.length; x++) {
			if(arr[x] > max) {
				max = arr[x];
			}
		}
		
		return max;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

6. 数组反转

package com.demo;

import java.util.Scanner;

/*
 * 需求：
 * (1)键盘录入5个int类型的数据存储数组arr中
 * (2)定义方法将arr数组中的内容反转
 * (3)定义方法对反转后的数组进行遍历
 * 
 * 分析：
 * 		A:定义一个长度为5的数组
 * 		B:通过键盘录入数据给数组中的元素赋值
 * 		C:定义方法将arr数组中的内容反转
 * 			什么是反转?如何实现反转
 * 		D:定义方法对反转后的数组进行遍历
 */
public class Test7 {
	public static void main(String[] args) {
		//定义一个长度为5的数组
		int[] arr = new int[5];
		
		//通过键盘录入数据给数组中的元素赋值
		Scanner sc = new Scanner(System.in);
		for(int x=0; x<arr.length; x++) {
			System.out.println("请输入"+(x+1)+"个元素值：");
			int number = sc.nextInt();
			arr[x] = number;
		}
		
		//反转前
		printArray(arr);
		
		//定义方法将arr数组中的内容反转
		reverse(arr);
		
		//定义方法对反转后的数组进行遍历
		printArray(arr);
	}
	
	//遍历数组
	public static void printArray(int[] arr) {
		System.out.print("[");
		for(int x=0; x<arr.length; x++) {
			if(x==arr.length-1) {
				System.out.println(arr[x]+"]");
			}else {
				System.out.print(arr[x]+", ");
			}
		}
	}
	
	/*
	 * 两个明确：
	 * 		返回值类型：void
	 * 		参数列表：int[] arr
	 */
	public static void reverse(int[] arr) {
		for(int start=0,end=arr.length-1; start<=end; start++,end--) {
			int temp = arr[start];
			arr[start] = arr[end];
			arr[end] = temp;
		}
	}
	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

7. 数组基本查找

package com.demo;

import java.util.Scanner;

/*
 * 需求：
 * (1)键盘录入5个int类型的数据存储数组arr中
 * (2)定义方法将arr数组中的内容反转
 * (3)定义方法对反转后的数组进行遍历
 * 
 * 分析：
 * 		A:定义一个长度为5的数组
 * 		B:通过键盘录入数据给数组中的元素赋值
 * 		C:定义方法将arr数组中的内容反转
 * 			什么是反转?如何实现反转
 * 		D:定义方法对反转后的数组进行遍历
 */
public class Test7 {
	public static void main(String[] args) {
		//定义一个长度为5的数组
		int[] arr = new int[5];
		
		//通过键盘录入数据给数组中的元素赋值
		Scanner sc = new Scanner(System.in);
		for(int x=0; x<arr.length; x++) {
			System.out.println("请输入"+(x+1)+"个元素值：");
			int number = sc.nextInt();
			arr[x] = number;
		}
		
		//反转前
		printArray(arr);
		
		//定义方法将arr数组中的内容反转
		reverse(arr);
		
		//定义方法对反转后的数组进行遍历
		printArray(arr);
	}
	
	//遍历数组
	public static void printArray(int[] arr) {
		System.out.print("[");
		for(int x=0; x<arr.length; x++) {
			if(x==arr.length-1) {
				System.out.println(arr[x]+"]");
			}else {
				System.out.print(arr[x]+", ");
			}
		}
	}
	
	/*
	 * 两个明确：
	 * 		返回值类型：void
	 * 		参数列表：int[] arr
	 */
	public static void reverse(int[] arr) {
		for(int start=0,end=arr.length-1; start<=end; start++,end--) {
			int temp = arr[start];
			arr[start] = arr[end];
			arr[end] = temp;
		}
	}
	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

8. 数据加密

package com.demo;

import java.util.Scanner;

/*
 * 需求：键盘录入数据,要求数据是四位的整数,现需要对数据进行加密,加密规则如下:
 * 每位数字都加上5,然后除以10的余数代替该数字,
 * 再将第一位和第四位交换,第二位和第三位交换,
 * 请把加密后的数据输出到控制台
 * 
 * 分析：
 * 		A:键盘录入一个4位数
 * 			举例：4567
 * 		B:定义一个长度为4的数组
 * 			int[] arr = new int[4];
 * 			arr = {4,5,6,7};
 * 		C:对数组中的数据进行加密规则的操作
 * 			每位数字都加上5,然后除以10的余数代替该数字
 * 				arr[x] += 5;
 * 				结果：arr = {9,10,11,12};
 * 				arr[x] %= 10;
 * 				结果：arr = {9,0,1,2};
 * 			再将第一位和第四位交换,第二位和第三位交换
 * 				结果：arr = {2,1,0,9};
 *		D:请把加密后的数据输出到控制台
 */
public class Test9 {
	public static void main(String[] args) {
		//键盘录入一个4位数
		Scanner sc = new Scanner(System.in);
		//接收数据
		System.out.println("请输入一个4位数：");
		int number = sc.nextInt();
		
		//定义一个长度为4的数组
		int[] arr = new int[4];
		arr[0] = number/10/10/10%10;
		arr[1] = number/10/10%10;
		arr[2] = number/10%10;
		arr[3] = number%10;
		
		//对数组中的数据进行加密规则的操作
		//每位数字都加上5,然后除以10的余数代替该数字
		for(int x=0; x<arr.length; x++) {
			arr[x] += 5;
			arr[x] %= 10;
		}
		
		//再将第一位和第四位交换,第二位和第三位交换
		int temp = arr[0];
		arr[0] = arr[3];
		arr[3] = temp;
		
		temp = arr[1];
		arr[1] = arr[2];
		arr[2] = temp;
		
		//请把加密后的数据输出到控制台
		for(int x=0; x<arr.length; x++) {
			System.out.print(arr[x]);
		}
		System.out.println();
	}
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

七、面向对象基础

1.面向对象思想概述及举例

我们回想一下，这几天我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后再分析怎么做，最后我们再代码体现。一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。
在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。
那么什么是面向过程开发呢? 面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
面向过程的代表语言：C语言

• 面向对象思想特点
  是一种更符合我们思考习惯的思想
  可以将复杂的事情简单化
  将我们从执行者变成了指挥者
  角色发生了转换
• 面向对象思想举例(demo01)
  买电脑
  洗衣服

2.类与对象及其使用

• 类与对象的关系
  我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。比如：去超市买东西的计费系统，去银行办业务的系统。
  我们如何表示一个现实世界事物呢：
  属性 就是该事物的描述信息
  行为 就是该事物能够做什么
  举例：学生事物
  我们学习的Java语言最基本单位是类，所以，我们就应该把事物用一个类来体现。
  类：是一组相关的属性和行为的集合
  对象：是该类事物的具体体现
  举例：
  类 学生
  对象 班长就是一个对象

• 类的定义
  现实世界的事物
  属性 事物的描述信息
  行为 事物能做什么

• Java中用class描述事物也是如此
  成员变量 就是事物的属性
  成员方法 就是事物的行为
  定义类其实就是定义类的成员(成员变量和成员方法)

• 学生类

package com.demo02;
/*
 * 类的定义：
 * 		类是用来描述现实世界的事物的
 * 
 * 事物：
 * 		属性	事物的描述信息
 * 		行为	事物能够做什么
 * 
 * 类是如何和事物进行对应的呢?
 * 		类：
 * 			成员变量
 * 			成员方法
 * 
 * 需求：写一个学生类
 * 
 * 学生事物：
 * 		属性：姓名，年龄...
 * 		行为：学习，吃饭...
 * 
 * 学生类：
 * 		成员变量：姓名,年龄
 * 		成员方法：学习,吃饭
 *
 * 成员变量：和我们前面学习过的变量的定义是一样的。
 * 		位置不同：类中，方法外
 * 		初始化值：不需要给初始化值
 * 成员方法：和我们前面学习过的方法的定义是一样的。
 * 		去掉static关键字
 */
public class Student {
	//成员变量
	//姓名
	String name;
	//年龄
	int age;
	
	//成员方法
	//学习的方法
	public void study() {
		System.out.println("好好学习，天天向上");
	}
	
	//吃饭的方法
	public void eat() {
		System.out.println("学习饿了要吃饭");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

• 学生类测试

package com.demo02;
/*
 * Student是一个学生事物描述类，main方法不适合放在它里面。
 * 
 * 使用一个类，其实就是使用该类的成员。(成员变量和成员方法)
 * 而我们要想使用一个类的成员，就必须首先拥有该类的对象。
 * 我们如何拥有一个类的对象呢?
 * 		创建对象就可以了?
 * 我们如何创建对象呢?
 * 		格式：类名 对象名 = new 类名();
 * 对象如何访问成员呢?
 * 		成员变量：对象名.变量名
 * 		成员方法：对象名.方法名(...)
 */
public class StudentDemo {
	public static void main(String[] args) {
		//格式：类名 对象名 = new 类名();
		Student s = new Student();
		//System.out.println("s:"+s); //com.demo02.Student@193c0cf
	
		/*//直接输出成员变量值
		System.out.println("姓名："+s.name); //null
		System.out.println("年龄："+s.age); //0
		System.out.println("----------");
		
		//给成员变量赋值
		s.name = "林青霞";
		s.age = 28;
		
		//再次输出成员变量的值
		System.out.println("姓名："+s.name); //林青霞
		System.out.println("年龄："+s.age); //28
		System.out.println("----------");*/
		
		//调用成员方法
		s.study();
		s.eat();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

如何定义
按照事物到类的过程一步步分析
如何使用
创建对象：
类名 对象名 = new 类名();
对象名.成员变量
对象名.成员方法

3.对象内存存储机制

• 1个对象的内存
  一个对象的基本初始化过程
• 2个对象的内存
  方法的共用
• 2个对象的内存
  两个引用指向同一个对象
  对象指向一个地址

package com.demo03;
/*
 * 手机类的测试类
 */
public class PhoneDemo3 {
	public static void main(String[] args) {
		Phone p = new Phone();
		p.brand = "OPPO";
		p.price = 2999;
		p.color = "白色";
		System.out.println("p:"+p);
		System.out.println(p.brand+"---"+p.price+"---"+p.color);
		
		Phone p2 = p;			//把p的内存地址直接给了p2
		p2.brand = "魅族";
		p2.price = 1999;
		p2.color = "蓝色";
		System.out.println("再次输出p:"+p);
		System.out.println("p2:"+p2);
		System.out.println(p.brand+"---"+p.price+"---"+p.color);
		System.out.println(p2.brand+"---"+p2.price+"---"+p2.color);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

输出结果：

4.成员变量和局部变量的区别

• 在类中的位置不同
  成员变量 类中方法外
  局部变量 方法内或者方法声明上，离开方法就不能用了。
• 在内存中的位置不同
  成员变量 堆内存
  局部变量 栈内存
• 生命周期不同
  成员变量 随着对象的存在而存在，随着对象的消失而消失
  局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
• 初始化值不同
  成员变量 有默认的初始化值
  局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。

一个标准的案例的使用

package com.demo04;
/*
 * 成员变量和局部变量的区别：
 * 		A:在类中的位置不同
 * 			成员变量：类中，方法外
 * 			局部变量：方法中或者方法声明上(形式参数)
 * 		B:在内存中的位置不同
 * 			成员变量：堆内存
 * 			局部变量：栈内存
 * 		C:生命周期不同
 * 			成员变量：随着对象的创建而存在，随着对象的消失而消失
 * 			局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
 * 		D:初始化值的问题
 * 			成员变量：有默认值
 * 			局部变量：没有默认值。必须先定义，赋值，最后使用
 */
public class Variable {
    int x;  //成员变量  堆内存
    public void show(){
        int y = 1;  //局部变量  栈内存
        System.out.println(x);
        System.out.println(y);
    }
    public static void main(String[] args){
        Variable v = new Variable();
        v.show();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

输出：
0
1

- private关键字

是一个权限修饰符。
可以修饰成员(成员变量和成员方法)
被private修饰的成员只在本类中才能访问。

• private最常见的应用：
  把成员变量用private修饰
  提供对应的getXxx()/setXxx()方法
  • setXxx() 赋值
  • getXxx() 获取值

Student:

package demo2;
/*
 * 学生类(私有）
 *
 * 通过对象直接访问成员变量，会存在数据安全问题
 * 这个时候，我们就想能不能不让外界的对象直接访问成员变量呢?
 * 能。
 * 如何实现呢?
 * 		private关键字
 *
 * private:
 * 		是一个修饰符
 * 		可以修饰成员变量，也可以修饰成员方法
 * 		==被private修饰的成员只能在本类中被访问==
 *
 * 针对private修饰的成员变量，我们会相应的提供getXxx()和setXxx()用于获取和设置成员变量的值,方法用public修饰
 */
public class Student {
   String name;
//    int age;
    private int age;
    public void show(){
        System.out.println("姓名:" + name + "年龄是:" + age);
    }

    public void setAge(int a) {
        if(a<0 || a>200){
            System.out.println("给你的年纪有误");
        }else{
            age = a;
        }
    }

    public int getAge() {
        return age;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

StudentDemo:

package demo2;

public class StudentDemo {
    public static void main(String[] args){
        Student s = new Student();
        s.show();
        s.name="小何";    //不是私有的所以可以直接访问
        s.setAge(-24);
        s.show();
    }
}
1
2
3
4
5
6
7
8
9
10
11

5.封装(private)

• 封装概述
  是面向对象三大特征之一。(其它两个是继承和多态）
  是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。就像刚才说的年龄。
• 封装原则：
  将不需要对外提供的内容都隐藏起来。
  把属性隐藏，提供公共方法对其访问。
  成员变量private，提供对应的getXxx()/setXxx()方法
• 好处：
  通过方法来控制成员变量的操作，提高了代码的安全性。
  把代码用方法进行封装，提高了代码的复用性。

Student:

package demo3;

public class Student {
    private String name;	//成员变量
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

StudentDemo

package demo3;

public class StudentDemo {
    public static void main(String[] args){
        Student s = new Student();
        s.setName("小何");
        s.setAge(11);
        System.out.println(s.getName() + s.getAge());
    }

}
1
2
3
4
5
6
7
8
9
10
11

6.this关键字

• this:代表所在类的对象引用
  记住：
  方法被哪个对象调用，this就代表哪个对象
  什么时候使用this呢?
  局部变量隐藏成员变量
  成员变量：在类中方法外。
  局部变量：方法中或方法声明上。

package com.demo07;
/*
 * 学生类
 * 
 * 起名字我们要求做到见名知意。
 * 而我们现在的代码中的n和a就没有做到见名知意，所以我要改进。
 * 
 * 如果有局部变量名和成员变量名相同，在局部使用的时候，采用的是就近的原则。
 * 
 * 我们有没有办法把局部变量的name赋值给成员变量的name呢?
 * 有。
 * 
 * 什么办法呢?
 * 		用this关键字就可以解决这个问题
 * 
 * this:代表所在类的对象引用
 * 		方法被哪个对象调用，this就代表那个对象
 * 
 * 使用场景：
 * 		局部变量隐藏成员变量
 */
public class Student {
	private String name;
	private int age;
	
	public void setName(String name) { //"林青霞"
		//name = n;
		this.name = name;
	}
	
	public String getName() {
		return name;
	}
	
	public void setAge(int age) {
		//age = age;
		this.age = age;
	}
	
	public int getAge() {
		return age;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

7.构造方法

• 构造方法作用概述
  给对象的数据进行初始化
• 构造方法格式
  方法名与类名相同
  没有返回值类型，连void都没有
  没有具体的返回值
• 构造方法注意事项
  如果你不提供构造方法，系统会给出默认构造方法
  如果你提供了构造方法，系统将不再提供
  构造方法也是可以重载的
• 标准类的代码写法和测试
• 类
  • 成员变量
  • 构造方法
    无参构造方法
    带参构造方法
  • 成员方法
    getXxx()
    setXxx()
    get方法是获得这个属性
    set方法是给这个属性赋值
• 给成员变量赋值的方式
  无参构造方法+setXxx()
  带参构造方法

package com.demo08;
/*
 * 构造方法：
 * 		给对象的数据进行初始化
 * 
 * 格式：
 * 		方法名和类名相同
 * 		没有返回值类型，连void都不能写
 * 		没有具体的返回值
 * 
 * 构造方法的注意事项：
 * 		A:如果我们没有给出构造方法，系统将会提供一个默认的无参构造方法供我们使用。
 * 		B:如果我们给出了构造方法，系统将不再提供默认的无参构造方法供我们使用。
 *        这个时候，如果我们想使用无参构造方法，就必须自己提供。
 *        推荐：自己给无参构造方法
 *      C:构造方法也是可以重载的
 * 
 * 成员变量赋值：
 * 		A:setXxx()方法
 * 		B:带参构造方法	
 */
public class Student {
	private String name;
	private int age;
	
	/*
	public Student() {
		System.out.println("这是构造方法");
	}
	*/
	
	public Student() {}
	
	public Student(String name) {
		this.name = name;
	}
	
	public Student(int age) {
		this.age = age;
	}
	
	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}

	public void show() {
		System.out.println(name+"---"+age);
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

package com.demo08;

public class StudentDemo {
	public static void main(String[] args) {
		//如何调用构造方法呢?
		//通过new关键字调用
		//格式：类名 对象名 = new 构造方法(...);
		//Student s = new Student();
		//s.setName("张三");
		//s.setAge(18);
		//s.show();
		
		//public Student(String name)
		//Student s2 = new Student("林青霞");
		//s2.show();
		
		//public Student(int age)
		/*Student s3 = new Student(28);
		s3.show();*/
		
		//public Student(String name,int age)
		Student s4 = new Student("林青霞",28);
		s4.show();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

8.标准类的代码写法和测试

• 类
  成员变量
  构造方法
  • 无参构造方法
  • 带参构造方法
    成员方法
    getXxx()
    setXxx()
    给成员变量赋值的方式
  • 无参构造方法+setXxx()
  • 带参构造方法
    类名作为形式参数案例
    要的其实是该类的对象
    类名作为返回值案例
    返回的其实是该类的对象
    student

package com.demo09;
/*
 * 学生类
 */
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;
	}
	
	/**
	 * 给年龄赋值
	 * @param age 年龄
	 */
	public void setAge(int age) {
		this.age = age;
	}
	
	/**
	 * 获取年龄
	 * @return 年龄
	 */
	public int getAge() {
		return age;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

package com.demo09;
/*
 * 学生类的测试类
 */
public class StudentDemo {
	public static void main(String[] args) {
		//无参+setXxx()
		Student s = new  Student();
		s.setName("林青霞");
		s.setAge(28);
		System.out.println(s.getName()+"---"+s.getAge());
		
		//带参构造
		Student s2 = new Student("林青霞",28);
		System.out.println(s2.getName()+"---"+s2.getAge());
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

9.类名作为形式参数和返回值

• 类名作为形式参数案例
  要的其实是该类的对象
• 类名作为返回值案例
  返回的其实是该类的对象

package com.demo10;

public class Student {
	/**
	 * 学习
	 */
	public void study() {
		System.out.println("好好学习,天天向上");
	}
}

1
2
3
4
5
6
7
8
9
10
11

package com.demo10;

public class Teacher {
	/**
	 * 调用学生类的学习方法
	 * @param s 学生对象
	 */
	public void test(Student s) {
		s.study();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12

package com.demo10;

//需求： 调用Teacher的test方法

//类名作为形式参数：其实这里需要的是该类对象。
public class Test {
	public static void main(String[] args) {
		Teacher t = new Teacher();
		Student s = new Student();
		t.test(s);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

package com.demo11;

public class Teacher {
	
	public Student getStudent() {
		Student s = new Student();
		return s;
	}
}

1
2
3
4
5
6
7
8
9
10

package com.demo11;

//需求： 通过Teacher得到Student对象，然后调用Student类的方法
//如果方法的返回值是类名：其实返回的是该类的对象
public class Test {
	public static void main(String[] args) {
		Teacher t = new Teacher();
		Student s = t.getStudent();
		//Student s = new Student();
		s.study();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

八、java常用API

API概述

API(Application Programming Interface)
应用程序编程接口
编写一个机器人程序去控制机器人踢足球，程序就需要向机器人发出向前跑、向后跑、射门、抢球等各种命令，没有编过程序的人很难想象这样的程序如何编写。但是对于有经验的开发人员来说，知道机器人厂商一定会提供一些用于控制机器人的Java类，这些类中定义好了操作机器人各种动作的方法。其实，这些Java类就是机器人厂商提供给应用程序编程的接口，大家把这些类称为API。本章涉及的Java API指的就是JDK中提供的各种功能的Java类。

-如何使用API
（1）打开帮助文档
点击显示，找到索引，看到输入框
你要找谁?
在输入框里输入，然后回车


例如：Scanner，点击第一个

CTRL+F查找

String s = sc.nextLine();
int month = sc.nextInt();

（2）看包
java.lang下的类不需要导包，其他需要
（3）看类的解释和说明
（4）学习构造方法
（5）使用成员方法

String

• String类的概述及构造方法
  String类概述
  字符串是由多个字符组成的一串数据
  字符串可以看成是字符数组
  构造方法
  public String(String original)
  public String(char[] value)
  public String(char[] value,int offset,int count)
  直接赋值也可以是一个对象

• String的特点
  通过构造方法创建字符串对象
  String s = new String(“hello”);
  直接赋值创建字符串对象
  String s = “hello”;区别是什么?

• String类的判断功能
  boolean equals(Object obj) 判断字符串是否相等
  boolean equalsIgnoreCase(String str) 不区分字符串大小写
  boolean startsWith(String str) 判断以什么字符串为开始
  
  boolean endsWith(String str) 以什么为结束，同endsEnd。
  API中的equal:
  
  Equal测试：

package com.demo03;
/*
 * Object:是类层次结构中的根类，所有的类都直接或者间接的继承自该类。
 * 如果一个方法的形式参数是Object，那么这里我们就可以传递它的任意的子类对象。
 * 
 * String类的判断功能：
 * boolean equals(Object obj):比较字符串的内容是否相同
 * boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
 * boolean startsWith(String str):判断字符串对象是否以指定的str开头
 * boolean endsWith(String str):判断字符串对象是否以指定的str结尾
 */
public class StringDemo {
	public static void main(String[] args) {
		//创建字符串对象
		String s1 = "hello";
		String s2 = "hello";
		String s3 = "Hello";
		
		//boolean equals(Object obj):比较字符串的内容是否相同
		/*System.out.println(s1.equals(s2));
		System.out.println(s1.equals(s3));
		System.out.println("-----------");*/
		
		//boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
		/*System.out.println(s1.equalsIgnoreCase(s2));
		System.out.println(s1.equalsIgnoreCase(s3));
		System.out.println("-----------");*/
		
		//boolean startsWith(String str):判断字符串对象是否以指定的str开头
		/*System.out.println(s1.startsWith("he"));
		System.out.println(s1.startsWith("ll"));
		*/
		//boolean endsWith(String str):判断字符串对象是否以指定的str结束
		System.out.println(s1.endsWith("ll"));
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

练习: 模拟用户登录

package demo5_api;

import java.util.Scanner;

/**
 * 模拟用户登录 equal的用法 给三次机会,并提示还有几次。
 * A 定义2个字符串对象，是正确的账号和密码
 * B 键盘录入账号和密码，并规定3次机会
 * C 判断输入的账号密码和正确的是否一样，一样：登陆成功，记得break跳出循环，不一样：失败还有2-x次机会；第三次：账号锁定，次数用完
 */
public class UserLogin {
    public static void main(String[] args) {
//  1.定义两个字符串对象，用于存储已经存在的用户名和密码
        String name = "admin";
        String password = "123456";
//  2.键盘录入 3次机会
        for (int x = 0; x < 3; x++) {
            Scanner scanner = new Scanner(System.in);
            System.out.println("输入账号:");
            String userName = scanner.nextLine();
            System.out.println("输入密码:");
            String userPsd = scanner.nextLine();
            if (userName.equals(name) && userPsd.equals(userPsd)) {
                System.out.println("登陆成功");
                break;
            } else if ((2 - x) == 0) {
                System.out.println("次数用完");
            } else {
                System.out.println("还剩余" + (2 - x) + "次机会");
            }
        }


    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

• String类的获取功能
  int length() 字符串的长度
  char charAt(int index) 整型变量所在位置的字符
  int indexOf(String str) 字符串在整个字符串中的位置
  String substring(int start) 取子字符串，从start开始取字符串
  String substring(int start,int end) 从start开始取字符串，到end结束，不包括第end个。

length与size的区别

java中的length属性是针对数组说的。比如你声明了一个数组(int[] a),想知道这个数组的长度则可以用到length这个属性。
java中的length()方法是针对字符串String说的，如果想看字符串的长度则可以用到length()这个方法
java中的size()方法是针对泛型集合说的，如果想看这个泛型有多少个元素，就调用次方法来查看.
举个例子:

public static void main(String[] args) {
String []list={“ma”,“cao”,“yuan”};
String a=“macaoyuan”;
System.out.println(list.length);
System.out.println(a.length());

    List