首页 > 编程学习 > java从零开始系统性学习完整超全资源+笔记(还在更新中)

java从零开始系统性学习完整超全资源+笔记(还在更新中)

前言

资源来自:王汉远java基础,
B站视频: https://www.bilibili.com/video/BV1b4411g7bj/?spm_id_from=333.1007.top_right_bar_window_custom_collection.content.click&vd_source=33eb2731cb742522d03acd26e5b17ba3
网盘链接(含源代码和笔记资料PPT):1,java基础学习:
链接:https://pan.baidu.com/s/1lxrpAW6yAxzSouYQz-GaKg
提取码:anr4
课件:
链接:https://pan.baidu.com/s/1zV-4jtSKHzkmS4c6wp7Qag
提取码:cgw6
下半部分
链接:https://pan.baidu.com/s/15xOnqGo-CQelWyk4naVsJQ
提取码:sk57
之前学的java忘记差不多了,最近得好好再学一遍,计划三周学完,特写此笔记便于后期做毕设项目和工作使用。
学习开始日期:2022.11.2
学习截止日期:进行中
**注意:**视频是基于eclipse进行编写的,最好还是用IDEA,eclipse老旧了,但是基本知识点还是不变的,等下学完这些视频,和IEDA里面有不同的地方再进行对比补充笔记。
IDEA版本:链接:https://pan.baidu.com/s/1znJc2zSpj84cvB6DGQ5NAw
提取码:pj3r

文章目录

  • java从零开始系统性学习完整超全资源+笔记(还在更新中)
    • 前言
    • 一、变量与数据类型
      • Java语言概述
      • 常用DOS命令
      • HelloWorld案例
      • 注释
      • 关键字
      • 常量
      • 变量
      • 数据类型
      • 标示符
    • 二、Eclipse/IDEA基本使用与配置
      • **1:基本使用**
      • **2:基本配置**
      • 3:删除和导入项目
      • 4.快捷键汇总
    • 三、运算符和表达式
      • 运算符
      • 键盘录入
    • 四、条件判断与循环语句
      • 选择结构
      • 循环结构
      • 随机数
    • 数组
      • 一维数组&内存图解
      • 二维数组


一、变量与数据类型

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

单词拼写注意问题:
在这里插入图片描述


注释

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

关键字

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

常量

常量概述:
在程序执行的过程中,其值不可以发生改变的量
常量分类
-字符串常量
用双引号括起来的内容(“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);
	}

变量

  • 变量概述

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

    • 数据类型 变量名=初始化值;
    • 注意:格式是固定的,记住格式,以不变应万变
  • 计算机存储单元
    变量是内存中的小容器,用来存储数据。那么计算机内存是怎么存储数据的呢?无论是内存还是硬盘,计算机存储设备的最小信息单元叫“位(bit)”,我们又称之为“比特位”,通常用小写的字母b表示。而计算机最小的存储单元叫“字节(byte)”,通常用大写字母B表示,字节是由连续的8个位组成。
    除了字节外还有一些常用的存储单位,大家可能比较熟悉,我们一起来看看:
    1B(字节) = 8bit
    1KB = 1024B
    1MB = 1024KB
    1GB = 1024MB
    1TB = 1024GB

数据类型

Java语言是强类型语言,对于每一种数据都给出了明确的数据类型,不同的数据类型也分配了不同的内存空间,所以它们表示的数据大小也是不一样的。
在这里插入图片描述
基本数据类型(4类8种)
在这里插入图片描述

标示符

  • 作用
    给包,类,方法,变量等起名字

  • 组成规则
    由字符,下划线_,美元符$组成

  • 这里的字符采用的是unicode字符集,所以包括英文大小写字母,中文字符,数字字符等。

  • 注意事项

    • 不能以数字开头
    • 不能是Java中的关键字
  • 命名规则

    • 基本要求
      见名知意
  • 常见命名的规则

    • 包 (其实就是文件夹,用于对类进行管理)
      全部小写,多级包用点隔开。
      com,cn,com.demo
    • 一个单词首字母大写 Student,Car
    • 多个单词,每个单词首字母大写 HelloWorld
  • 变量或者方法

    • 一个单词首字母小写。 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即可

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

3:删除和导入项目

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

创建eclipse程序如图
在这里插入图片描述

4.快捷键汇总

  • 自己常用的
    注释:Ctrl+/ | Ctrl+Shift+/ 前者将当前行注释掉(行首加上//) ,后者将当前选中的内容注释掉(两端打上/* … */)
    内容辅助:Alt + / 自动写代码,类似代码提示。
    方法定位:按住Ctr1+鼠标左键,可以快速定位到对应的变量、方法或者其他的类等。
    格式化:ctrl+shift+F
    或者设置保存(ctrl+S)的时候格式化
    导包: CTRL + SHIFT + O
    在这里插入图片描述

注释多行代码: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的比较
    在这里插入图片描述

三、运算符和表达式

运算符

代码

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;		
	}
}

运算符

  • 对常量和变量进行操作的符号称为运算符
    表达式
  • 用运算符把常量或者变量连接起来符合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);

输出结果:

11
5
6

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

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

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

-逻辑运算符
• 逻辑运算符用于连接布尔型表达式,在Java中不
可以写成3<x<6,应该写成x>3 && 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();

核心步骤:

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

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

代码:

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

	}
}

四、条件判断与循环语句

选择结构

  • if
    if语句有三种格式
    if语句第一种格式:
if(关系表达式) {
		     语句体
	}

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

if语句第二种格式:

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

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

if语句第三种格式:

if(关系表达式1) {
		     语句体1;
	}else  if (关系表达式2) {
		     语句体2;
	}else {
		     语句体n+1;
	}
  • switch
    switch语句格式:
switch(表达式) {
	      case 值1:
			语句体1;
			break;
		    case 值2:
			语句体2;
			break;
		    …
		    default:	
			语句体n+1;
			break;
    }

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

循环结构

  • for
    for循环语句格式:
for(初始化语句;判断条件语句;控制条件语句) {
         循环体语句;
    }

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

  • while
    while循环语句格式:
基本格式
   while(判断条件语句) {
         循环体语句;
   }
改版格式
   初始化语句;
   while(判断条件语句) {
         循环体语句;
         控制条件语句;
    }
  • do … while
    do…while循环语句格式:
    基本格式
 do {
         循环体语句;
   }while((判断条件语句);
改版格式
   初始化语句;
   do {
         循环体语句;
         控制条件语句;
    } while((判断条件语句);
  • 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

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

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

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

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

综合练习
猜数字小游戏案例
系统产生一个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:数据类型 数组名[];
注意:这两种定义做完了,数组中是没有元素值的。

数组初始化概述:
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]);
		}
	}
}
  • 获取数值长度:数值名.length
  • 数组获取最值(获取数组中的最大值最小值)
    先画图,然后讲解

二维数组

  • 定义格式
    数据类型[][] 数组名;
    数据类型 数组名[][]; 不推荐
    数据类型[] 数组名[]; 不推荐
  • 初始化方式
    数据类型[][] 变量名 = new 数据类型[m][n];
    数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
    简化版格式:数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
  • 二维数组遍历
    int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
Copyright © 2010-2022 dgrt.cn 版权所有 |关于我们| 联系方式