黑马程序员Java零基础视频教程_上部（P1-P80）
黑马程序员Java零基础视频教程_上部（P1-P80）
- 1. Java入门
-
- 1.1 Java学习介绍
- 1.2 Java人机交互
-
- 1.2.1 常用CMD命令
- 2. Java基础学习
-
- 2.1 Java入门
-
- 2.1.1 HelloWorld代码案例
- 2.1.2 配置Path环境变量
- 2.1.3 Java语言发展
- 2.1.4 Java能干什么？
- 2.2.5 Java为什么这么火？
- 2.2 小概念
-
- 2.2.1 注释、关键字、字面量
- 2.2.2 \t制表符
- 2.2.3 变量的注意事项
- 2.2.4 变量计算-计算公交车人数
- 2.2.5 计算机的存储规则
- 2.2.6 计算机的存储规则
- 2.2.7 数据类型
- 2.2.8 标识符
- 2.2.9 键盘录入
- 2.3 Idea和运算符
-
- 2.3.1 IDEA
- 2.3.2 运算符
- 2.4 判断和循环
-
- 2.4.1 顺序结构：
- 2.4.2 分支结构：If语句
- 2.4.3 分支结构：switch语句
- 2.4.4 分支结构：For语句
- 2.4.5 分支结构：While语句
- 2.4.6 分支结构：Do...While语句
- 2.4.7 无限循环
- 2.4.8 跳转控制语句
- 2.5 数组
-
- 2.5.1 数组介绍
- 2.5.2 数组的定义与静态初始化
- 2.5.3 数组元素访问
- 2.5.4 数组遍历
- 2.5.5 数组动态初始化
- 2.5.6 数组内存图
- 2.5.7 数组常见问题
- 2.5.8 数组常见操作
- 2.6 方法
-
- 2.6.1 什么是方法?
- 2.6.2 方法的格式
- 2.6.3 方法的调用
- 2.6.4 方法的重载
- 2.6.5 方法的内存
- 3.综合练习
-
- 3.1 买飞机票
- 3.2 找质数
- 3.3 开发验证码
- 3.4 数值元素的复制
- 3.5 评委打分
- 3.6 数学加密和解密
- 3.7 抽奖的两种实现方式
- 3.8 双色球彩票系统
- 3.9 二维数组
1. Java入门
1.1 Java学习介绍
1.2 Java人机交互
- Win+R，打开运行界面
- 输入CMD
盘符名称+冒号:
说明：盘符切换
举例：E:回车，表示切换到E盘
dir
说明：查看当前路径下的内容. （隐藏的文件夹也有）
cd目录
说明：进入单级目录
举例：
1.2.1 常用CMD命令
cd …
说明:回退到上一级目录
cd目录1\目录2…
说明：进入多级目录。
举例：cd itheima\VavaSE
cd \
说明：回退到盘符目录。
cls
说明：清屏。
exit
说明：退出命令提示符窗口。
QQ是经常打开的软件，每次打开的时候都要切换盘符，并且进入多层文件夹，太麻烦了!
只要把QQ的路径记录在电脑的环境变量里！！在当前目录下寻找后，如果没有找到，就去环境变量里去找。
Win+E，右键属性，高级系统设置，高级，环境变量。
把QQ的路径记录在Path里，当找环境变量时，会在path中从上至下寻找。
注意修改后，原来的CMD不作用，要新建有个CMD。
2. Java基础学习
2.1 Java入门
1、JDK
JDK是Java初学时用的，比较麻烦，小千建议大家开始学习Java的时候结合记事本使用，可以强迫熟悉Java语句和Java程序的基础结构。当然严格来说，编程软件里面应该不包括它，它只是支持Java的底层工具。
2、Jbuilder
Jbuilder是一个可视化Java开发工具。它是在Java2平台上开发商业应用程序、数据库、发布程序的优秀工具。它支持J2EE，所以程序员可以快速的转换企业版Java应用程序。
JBuilder 对重量级框架的支持比较好。比如EJB。
3、Eclipse
Eclipse是一个开放源代码的、基于Java的可扩展开发平台。就其本身而言，它只是一个框架和一组服务，用于通过插件组件构建开发环境。幸运的是，Eclipse 附带了一个标准的插件集，包括Java开发工具(Java Development Kit，JDK)。
Eclipse对轻量级框架的支持比较好。比如Struts、Hibernate。
4、NetBeans
NetBeans包括开源的开发环境和应用平台，NetBeans IDE可以使开发人员利用Java平台能够快速创建Web、企业、桌面以及移动的应用程序，NetBeans IDE已经支持PHP、Ruby、Java、Groovy、Grails和C/C++等开发语言。
NetBeans对做Web开发比较好。
5、MyEclipse
MyEclipse是在eclipse基础上加上自己的插件开发而成的功能强大的企业级集成开发环境，主要用于Java、Java EE以及移动应用的开发。MyEclipse的功能非常强大，支持也十分广泛，尤其是对各种开源产品的支持相当不错。
学Java用什么软件好呢？目前使用比较多的就是Eclipse和Myeclipse，因为它是开源的，免费的。当然工具是死的，人是活的，Java用什么软件好还要因人而异，所以小千建议大家每个软件都试用一下，每个人的编程习惯不同，所以适合和喜欢的软件自然也不相同。
下面以JDK为例：
bin:该路径下存放了各种工具命令。其中比较重要的有: javac和java
conf:该路径下存放了相关配置文件。
include:该路径下存放了一些平台特定的头文件。
jmods:该路径下存放了各种模块。
legal:该路径下存放了各模块的授权文档。
lib:该路径下存放了工具的一些补充AR包。
2.1.1 HelloWorld代码案例
public class HelloWorld{
public static void main(String[] args){
System.out.println("HelloWorld");
}
}
2.1.2 配置Path环境变量
2.1.3 Java语言发展
紧贴市场发展
2.1.4 Java能干什么？
三大使用平台：JavaSE、JavaME、JavaEE
2.2.5 Java为什么这么火？
JVM (Java Virtual Machine) : Java虚拟机，真正运行Java程序的地方
- JDK是什么?有哪些内容组成?
JDK是Java开发工具包
●JVM虛 拟机: Java程序运行的地方
●核心类库: Java已经写好的东西，我们可以直接用。
●开发工具: javac、java、 jdb、jhat… - jJRE是什么? 有哪些内容组成?
JRE是Java运行环境
JVM、核心类库、运行工具 - jDK, JRE, JVM三者的包含关系
●JDK包含了JRE
●JRE包含 了JVM
2.2 小概念
2.2.1 注释、关键字、字面量
-
注释：注释是在程序指定位置添加的说明性信息，简单理解，就是对代码的一种解释
-
关键字：被Java赋予了特定涵义的英文单词
- 字面量：整数类型、小数类型、字符串类型、字符类型、布尔类型、空类型
public class Main {
public static void main(String[] args) {
System.out.println("Hello world!");
//整数
System.out.println(666);
System.out.println(-999);
//小数
System.out.println(-1.2);
//字符
System.out.println('男');
//Bool
System.out.println(true);
System.out.println(false);
}
}
2.2.2 \t制表符
在打印的时候，把前面字符串的长度补齐到8，或者8的整数倍。最少补1个空格，最多补8个空格。
public class Main {
public static void main(String[] args) {
System.out.println("Hello"+'\t'+"World");
System.out.println("HelloWorld");
// Hello World
// HelloWorld
}
}
变量：数据类型 变量名=数据值；
public class Main {
public static void main(String[] args) {
//定义变量
//数据类型变量名=数据值;
//数据类型:限定了变量能存储数据的类型
//int (整数) double (小数)
//变量名:就是存储空间的名字
//作用:方便以后使用
//数据值:真正存在变量中的数据
//等号:赋值。把右边的数据赋值给左边的变量
int a = 10;
double b = 10.1;
System.out.println (a) ;
System.out.println (b) ;
}
}
public class Main {
public static void main(String[] args) {
//1.基本用法
//定义变量，再进行输出
int a= 10;
System.out.println(a) ;//10
System.out.println(a) ;//10
System.out.println(a) ;//10
//int a =20 ; 报错
//2.变量参与计算
int b= 30;
int c= 20;
System.out.println(b + c) ;
//3.修改变量的值
b = 70;
System.out.println(b) ;
//4.定义多个变量
int d=100,e=200,f=300;
System.out.println(d) ;
System.out.println(e) ;
System.out.println(f) ;
//5.System.out.println(g) ;报错
boolean w = true;
System.out.println(w);
}
}
2.2.3 变量的注意事项
- 只能存一个值
- 变量名不允许重复定义
- 一条语句可以定义多个变量
- 变量在使用之前一定要进行赋值
- 变量的作用域范围
2.2.4 变量计算-计算公交车人数
public class Main {
public static void main(String[] args) {
//一开始没有乘客。
int count = 0;
//第一站:上去一位乘客
//在原有的基础上+1
count=count+1;
// System.out.println(count) ;
//第二站:上去两位乘客，下来一位乘客
count=count+2-1;
//第三站:上去两位乘客，下来一位乘客
count=count+2-1;
//第四站:下来一位乘客
count=count-1;
//第五站:上去一位乘客
count=count+1;
//请问:到了终点站,车上一共几位乘客。
System.out.println(count) ;//3| I
}
}
2.2.5 计算机的存储规则
在计算机中，任意数据都是以二进制的形式来存储的。
2.2.6 计算机的存储规则
- GB2312编码: 1981年5月1日发布的简体中文汉字编码国家标准。收录7445个图形字符，其中包括6763个汉字。
- BIG5编码: 台湾地区繁体中文标准字符集，共收录13053个中文字，1984年实施。
- GBK编码: 2000年3月17日发布，收录21003个汉字，包含国家标准GB13000-1中的全部中日韩汉字，和BIG5编码中的所有汉字。
- Unicode编码: 国际标准字符集，它将世界各种语言的每个字符定义- -个唯- -的编码，以满足跨语言、跨平台的文本信息转换。
2.2.7 数据类型
- 基本数据类型：
public class Main {
public static void main(String[] args) {
//byte
byte b = 10;
System.out.println(b) ;//10
//short
short s=20;
System.out.println(s) ; //20
//int
int i=30;
System.out.println(i) ; //30
// long
//如果要定义long类型的变量
//在数据值的后面需要加一个L作为后缀
//L可以是大写的， 也可以是小写的。
//建议:使用大写。
long n = 9999999999L;
System.out.println(n);
}
}
public class Main {
public static void main(String[] args) {
float f =10.1F;
System.out.println(f) ;
//double
double d = 20.2 ;
System.out.println(d) ;
//char
char c='中';
System.out.println(c) ;
//boolean
//true false
boolean o = true ;
System.out.println(o) ;
}
}
整数和小数取值范围大小关系：double > float > long > int > short > byte
long类型变量：需要加入L标识(大小写都可以)
float类型变量：需要加入F标识(大小写都可以)
public class Main {
public static void main(String[] args) {
String name = "黑马王大拿";
int age = 18;
char gender = '男';
double height =180.1;
boolean flag = true;
System.out.println("name:"+'\t'+name);
System.out.println("age:"+'\t'+age);
System.out.println("gender:"+'\t'+gender);
System.out.println("height:"+'\t'+height);
System.out.println("flag:"+'\t'+flag);
// name: 黑马王大拿
// age: 18
// gender: 男
// height: 180.1
// flag: true
}
}
- 引用数据类型：
类、 接口类型、 数组类型、 枚举类型、 注解类型、 字符串型，例：String类型就是引用类型
2.2.8 标识符
标识符命名规则——硬性要求
- 由数字、字母、下划线(_ )和美元符($)
- 组成 不能以数字开头
- 不能是关键字
- 区分大小写
标识符命名规则——软性建议
- 小驼峰命名法：方法、变量
- 规范1:标识符是一个单词的时候，全部小写
- 范例1: name
- 规范2:标识符由多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写
- 范例2: firstName
大驼峰命名法：类名
- 规范1:标识符是一个单词的时候，首字母大写
- 范例1: Student
- 规范2:标识符由多个单词组成的时候，每个单词的首字母大写
- 范例2: GoodStudent
2.2.9 键盘录入
Java帮我们写好一个类叫Scanner，这个类就可以接收键盘输入的数字。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("Please input int:");
int s = sc.nextInt();
System.out.println(s);
}
}
输入2个数字：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("Please input first num:");
int s = sc.nextInt();
System.out.println("Please input second num:");
int a = sc.nextInt();
System.out.println("Add:");
System.out.println(s+a);
}
}
2.3 Idea和运算符
2.3.1 IDEA
看看2位大牛的文字。
IntelliJ IDEA 下载安装及配置教程
IDEA放大和缩小代码字体的快捷键设置
IDEA中类相关操作：修改类名、删除类、新建类
注意：文件名与类名保持一致
IDEA中模块相关操作：新建模块、删除模块、修改模块、导入模块
IDEA中项目相关操作：关闭项目、新建项目、打开项目、修改项目
2.3.2 运算符
算术运算符
public class Main {
public static void main(String[] args) {
//+
System.out.println(3 + 2);//5
//-
System.out.println(5 - 1);//4.
//* (shift +数字8)
System.out.println(7 * 9);//63
//如果在计算的时候有小数参与 有可能不精确
System.out.println(1.1 + 1.01);
System.out.println(1.1 - 1.01);
System.out.println(1.1 * 1.01);
// /
System.out.println(10/3); //3
System.out.println(10.0/3); //3.333333333333333333335
// 取模
System.out.println(10%3); //1
}
}
输出三位数的个、十、百
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("please input a 三位数");
int num = sc.nextInt();
System.out.println("个位"+'\t'+num%10);
System.out.println("十位"+'\t'+(num/10)%10);
System.out.println("百位"+'\t'+num/100);
}
}
public class Main {
public static void main(String[] args) {
byte b1 = 19;
byte b2 = 20;
//现在我们要强转的是谁?
//b1 + b2计算之后的结果。
// (byte)b1 + b2强转的是b1，并不是最终的结果
byte result = (byte)(b1 + b2);
System. out. println(result);//
}
}
自增自减运算符
可以先写++a 也可后写a++
public class Main {
public static void main(String[] args) {
int x = 10;
int y = x++;
int z = ++x;
System.out.println(x); //12
System.out.println(y); //10
System.out.println(z); //12
}
}
赋值运算符
关系运算符
逻辑运算符
简单理解: 当左边的表达式能确定最终的结果，那么右边就不会参与运行了
三元运算符
运算符优先级
原码
补码完美解决了计算机中正数与负数计算问题。
计算机中是用补码计算的，所以一个字节是+127~-128
2.4 判断和循环
2.4.1 顺序结构：
public class Main {
public static void main(String[] args) {
System.out.println("努力做主人喜欢的事");
System.out.println("大小如驾到!统统闪开! ");
System.out.println("凛冬已至，故乡的梅花开了吗");
System.out.println("心怀不惧，方能翱翔于天际");
}
}
2.4.2 分支结构：If语句
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入女婿的酒量:");
int num = sc.nextInt();
if(num>10)
{
System.out.println("OK");
}
else {
System.out.println("Get Out");
}
}
}
在实际开发中，电影院选座也会使用到if判断。假设某影院售卖了100张票，票的序号为1~100。
其中奇数票号坐左侧，偶数票号坐右侧。键盘录入“个整数表示电影票的票号。
根据不同情况，给出不同的提示:如果票号为奇数，那么打印坐左边，如果票号为偶数，那么打印坐右边。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
//分析:
//1.键盘录入一个整数表示电影票的票号。
Scanner sc = new Scanner(System. in);
System.out.println("请录入一个票号");
int ticket = sc.nextInt();
//只有当ticket在0 ~ 100之间，才是真实有效的票
if(ticket >=0 && ticket <= 100){
//2.判断票号是奇数还是偶数
if(ticket % 2 == 1){
System.out.println("坐左边");
}else{
System.out.println("坐右边");
}
}
}
}
2.4.3 分支结构：switch语句
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入1到5之间的一个数，我会猜到他的属性:");
int num = sc.nextInt();
switch (num)
{
case 1:
System.out.println("比0大，比2小");break;
case 2:
System.out.println("比1大，比3小");break;
case 3:
System.out.println("比2大，比4小");break;
case 4:
System.out.println("比3大，比5小");break;
case 5:
System.out.println("比4大，比6小");break;
default:
System.out.println("请按照要求输入");break;
}
}
}
- 位置: defaule不一定是写在最下面的，我们可以写在任意位置。只不过习惯会写在最下面
- 省略: defaule可以省略， 语法不会有问题，但是不建议省略。
执行流程：
首先还是会拿着小括号中表达式的值跟下面每一个case进行匹配。
如果匹配上了，就会执行对应的语句体，如果此时发现了break，那么结束整个switch语句。
如果没有发现break，那么程序会继续执行下一个case的语句体，一 直遇到break或者右大括号为止。
switch新特性：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入1到5之间的一个数，我会猜到他的属性:");
int num = sc.nextInt();
switch (num)
{
case 1-> {
System.out.println("比0大，比2小");
}
case 2-> {
System.out.println("比1大，比3小");
}
case 3-> {
System.out.println("比2大，比4小");
}
case 4-> {
System.out.println("比3大，比5小");
}
case 5-> {
System.out.println("比4大，比6小");
}
default-> {
System.out.println("请按照要求输入");
}
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
//分析:
//1.键盘录入星期数
Scanner sc = new Scanner(System.in);
System.out.println("请录入一个整数表示星期");
int week = sc.nextInt();
//2.利用switch语句来进行选择
switch (week) {
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println("工作日");
break;
case 6:
case 7:
System.out.println("休息日");
break;
default:
System.out.println("没有这个星期");
break;
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
//分析:
//1.键盘录入星期数
Scanner sc = new Scanner(System.in);
System.out.println("请录入一个整数表示星期");
int week = sc.nextInt();
//2.利用switch语句来进行选择
switch (week) {
case 1,2,3,4,5 ->System.out.println("工作日");
case 6,7 ->System.out.println("休息日");
default -> System.out.println("没有这个星期");
}
}
}
2.4.4 分支结构：For语句
public class Main {
public static void main(String[] args) {
for(int i =1;i<5;i++)
{
System.out.println(i);
}
}
}
2.4.5 分支结构：While语句
public class Main {
public static void main(String[] args) {
int j = 1;
while(j<5)
{
System.out.println(j);
j++;
}
}
}
2.4.6 分支结构：Do…While语句
先执行 后判断。
2.4.7 无限循环
2.4.8 跳转控制语句
public class Main {
public static void main(String[] args) {
for(int i =1;i<5;i++)
{
if(i ==3)
{
continue;
}
System.out.println(i);
}
}
}
2.5 数组
2.5.1 数组介绍
2.5.2 数组的定义与静态初始化
数组的初始化: 就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程。
完整格式：数据类型[] 数组名 = new 数据类型[] {元素1,元素2，元素3... };
省略格式：数据类型[] 数组名 = {元素1,元素2，元素3... };
数值一旦确定长度，长度不可发生改变。
public class Main {
public static void main(String[] args) {
//需求1:定义数组存储4个学生的年龄
int[] arr1 = new int[]{11,12,13,14};
int[] arr2 = {11,12,13,14};
//需求2:定义数组存储3个学生的姓名
String[] arr3 = new String[]{"zhangsan" ,"lisi", "wangwu"};
String[] arr4 = {" zhangsan", "lisi" ,"wangwu"};
//需求3:定义数组存储4个学生的身高1.93
double[] arrs = new double[]{1.93,1.75,1.73,1.81};
double[] arr6 = {1.93,1.75,1.73,1.81};
}
}
public class Main {
public static void main(String[] args) {
int[] arr1 = new int[]{11,12,13,14};
int[] arr2 = {11,12,13,14};
System.out.println(arr1);//[I@7ef20235
//扩展:
// 解释一下地址值的格式含义[D@776ec8df
//[ :表示当前是一一个数组
//D:表示当前数组里面的元素都是double类型的
//@:表示一个间隔符号。(固定格式)
//776ec8df:才是数组真正的地址值，(十六进制)
//平时我们习惯性的会把这个整体叫做数组的地址值。
}
}
2.5.3 数组元素访问
public class Main {
public static void main(String[] args) {
int[] arr1 = new int[]{11,12,13,14};
int[] arr2 = {11,12,13,14};
System.out.println(arr1[2]);//13
}
}
public class Main {
public static void main(String[] args) {
int[] arr1 = new int[]{11,12,13,14};
int[] arr2 = {11,12,13,14};
System.out.println(arr1[2]);//13
//2.把数据存储到数组当中
//格式:数组名[索引] =具体数据/变量;
//细节:一旦覆盖之后，原来的数据就不存在了。
arr1[2]=100;
System.out.println(arr1[2]);//100
}
}
2.5.4 数组遍历
数组遍历：将数组中所有的内容取出来，取出来之后可以(打印，求和，判断…)
注意：遍历指的是取出数据的过程，不要局限的理解为，遍历就是打印！
public class Main {
public static void main(String[] args) {
int[] arr1 = new int[]{11,12,13,14};
for (int i = 0;i< arr1.length;i++)
{
System.out.println(arr1[i]);
}
}
}
2.5.5 数组动态初始化
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
格式：数据类型[] 数组名 = new 数据类型[数组长度];
范例：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
//格式:
//数据类型[]数组名= new数据类型[数组的长度];
//在创建的时候，由我们自己指定数组的长度，由虚拟机给出默认的初始化值
String[] arr = new String[50];
//添加学生
arr[0] = "zhangsan";
arr[1] = "lisi";
//获取
System.out.println(arr[0]);//zhangsan
System.out.println(arr[1]);//lisi
System.out.println(arr[2]);//打印出来的是默认初始化值null
//数组默认初始化值的规律
//整数类型:默认初始化值0
//小数类型:默认初始化值0.0
//字符类型:默认初始化值' /u0000'空格
//布尔类型:默认初始化值false
//引用数据类型:默认初始化值null
}
}
数组动态初始化和静态初始化的区别
动态初始化:手动指定数组长度，由系统给出默认初始化值。
只明确元素个数，不明确具体数值，推荐使用动态初始化
- ➢举例：使用数组容器来存储键盘录入的5个整数。
- ➢
int[] arr={?????};
静态初始化:手动指定数组元素,系统会根据元素个数，计算出数组的长度。
需求中已经明确了要操作的具体数据，直接静态初始化即可。
2.5.6 数组内存图
注意:
从JDK8开始，取消方法区，新增元空间。把原来方法区的多种功能进行拆分,有的功能放到了堆中，有的功能放到了元空间中。
Java内存分配
- ●栈 方法运行时使用的内存，比如main方法运行，进入方法栈中执行
- ●堆 存储对象或者数组，new来创建的，都存储在堆内存
- ●方法区 存储可以运行的class文件
- ●本地方法栈 JVM在 使用操作系统功能的时候使用，和我们开发无关
- ●寄存器. 给CPU使用，和我们开发无关
变量中存储的是真实数据，数组内存存地址。
两个数组指向同一个空间的内存图。
2.5.7 数组常见问题
当访问了数组中不存在的索引，就会引发索引越界异常。
2.5.8 数组常见操作
求最值
public class Main {
public static void main(String[] args) {
int [] arr = {33,5,22,44,55};
int minn = arr[0];
int maxx = arr[0];
for(int i = 0;i < arr.length;i++)
{
if(arr[i]>maxx) maxx = arr[i];
if(arr[i]<minn) minn = arr[i];
}
System.out.println(maxx);
System.out.println(minn);
}
}
求和
public class Main {
public static void main(String[] args) {
int [] arr = {33,5,22,44,55};
int add = 0;
for(int i = 0;i < arr.length;i++)
{
add = add + arr[i];
}
System.out.println(add);
}
}
import java.util.Random;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
int [] arr = new int [10];
Random r = new Random();
for(int i = 0;i < arr.length;i++)
{
int num = r.nextInt(100)+1;
arr[i] = num;
}
int add = 0;
for(int i = 0;i < arr.length;i++)
{
add = add + arr[i];
}
System.out.println(add);
}
}
交换数据
import java.util.Random;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
//2.将数组中0索引和最大索引出的值进行交换
//也是可以利用第三方变量进行交换
int temp = arr[0];
arr[0] = arr[4];
arr[4] = temp;
//3.遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");//不换行
// System.out.println(arr[i] + " ");//换行
}
}
}
打乱数据
import java.util.Random;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
Random r = new Random();
int num = r.nextInt(arr.length);
for (int i = 0; i < arr.length; i++) {
int temp = arr[i];
arr[i] = arr[num];
arr[num] = temp;
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");//不换行
}
}
}
2.6 方法
2.6.1 什么是方法?
方法（method）是程序中最小的执行单元。
将重复的代码打包，避免重复度过高，复用性差。
- 什么是方法?
方法是程序中最小的执行单元。 - 实际开发中，什么时候用到方法?
重复的代码、具有独立功能的代码可以抽取到方法中。 - 实际开发中，方法有什么好处?
●可以提高代码的复用性
●可以提高代码的可维护性
2.6.2 方法的格式
public static 返回值类型 方法名(参数) {
方法体;
return 返回值;
}
2.6.3 方法的调用
public class Main {
public static void main(String[] args) {
playGame();
}
public static void playGame(){
System. out. println("选人物");
System. out. println("准备开局");
System. out. println("对线");
System. out. println("崩盘");
System. out. println("骂队友");
System. out. println("送人头");
System. out. println("GG");
}
}
带参数的调用：
public class Main {
public static void main(String[] args) {
GetSum(10,20);
GetSum(20,34);
}
public static void GetSum(int a,int b){
System. out. println(a+b);
}
}
public class Main {
public static void main(String[] args) {
double a = Square(1.1,2.2);
System.out.println(a);
}
public static double Square(double len,double width){
double result = (len+width)*2;
return result;
}
}
2.6.4 方法的重载
方法的重载：
●在同一个类中，定义了多个同名的方法,这些同名的方法具有同种的功能。
●每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成了重载关系
●简单记:同一个类中，方法名相同，参数不同的方法。与返回值无关。
参数不同:个数不同、类型不同、顺序不同
public class Main {
public static void main(String[] args) {
int [] arr = {1,2,3,4,5,6,7,8,9};
int [] r = copyOfRange(arr,0,6);
for(int i = 0;i< r.length;i++)
{
System.out.println(r[i]);
}
}
public static int[] copyOfRange(int[] arr,int from,int to)
{
int [] result = new int [to-from];
for(int i = 0;i<result.length;i++)
{
result[i] = arr[i+from];
}
return result;
}
}
2.6.5 方法的内存
1.方法调用的基本内存原理
栈是先进后出的！！
2.方法传递基本数据类型的内存原理
3.方法传递引用数据类型的内存原理
public class Main {
public static void main(String[] args) {
int number = 100;
System.out.println("调用change方法前:" + number);
change(number);
System.out.println("调用change方法后:" + number);
}
public static void change(int number) {
number =200;
}
}
变量是又作用范围的，只在属于自己的方法里有效。
传递基本数据类型时，传递的是真实的数据，形参的改变，不影响实际参数的值
public class Main {
public static void main(String[] args) {
int []number = {1,2,3};
System.out.println("调用change方法前:" + number[1]);
change(number);
System.out.println("调用change方法后:" + number[1]);
// 调用change方法前:2
// 调用change方法后:200
}
public static void change(int [] number) {
number[1] =200;
}
}
传递引用数据类型时，传递的是地址值，形参的改变，影响实际参数的值
3.综合练习
3.1 买飞机票
需求:
●机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱。
●按照如下规则计算机票价格:旺季(5-10月)头等舱9折,经济舱8.5折，淡季(11月到来年4月)头等舱7折,经济舱6.5折。
import java.sql.SQLOutput;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System. in);
System.out.println("请输入机票的原价");
int ticket = sc.nextInt();
System.out.println("请输入当前的月份");
int month = sc. nextInt();
System.out.println("请输入当前购买的舱位0头等舱,1经济舱");
int seat= sc.nextInt();
if(month>=5 && month<=10)
{
if(seat==0)
{
ticket = (int)(ticket * 0.9);
}
else
{
ticket = (int)(ticket * 0.85);
}
} else if ((month>=1&&month<=4)||(month >=11 && month<= 12)) {
if(seat==0)
{
ticket = (int)(ticket * 0.7);
}
else
{
ticket = (int)(ticket * 0.65);
}
}
else
{
System.out.println("不合法的月份");
}
System.out.println(ticket);
}
}
Ctrl+alt+M
import java.sql.SQLOutput;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System. in);
System.out.println("请输入机票的原价");
int ticket = sc.nextInt();
System.out.println("请输入当前的月份");
int month = sc. nextInt();
System.out.println("请输入当前购买的舱位0头等舱,1经济舱");
int seat= sc.nextInt();
if(month>=5 && month<=10)
{
ticket = getTicket(seat, ticket, 0.9, 0.85);
} else if ((month>=1&&month<=4)||(month >=11 && month<= 12)) {
ticket = getTicket(seat, ticket, 0.7, 0.65);
}
else
{
System.out.println("不合法的月份");
}
System.out.println(ticket);
}
public static int getTicket(int seat, int ticket, double x, double x1) {
if (seat == 0) {
ticket = (int) (ticket * x);
} else {
ticket = (int) (ticket * x1);
}
return ticket;
}
}
3.2 找质数
判断101-200之间有多少个质数。
public class Main {
public static void main(String[] args) {
//定义一个变量用来统计有多少个质数
int count = 0;
//外循环:遍历
for (int i = 101; i <= 200; i++) {
//i依次表示循环中的每一个数字
//继续判断i是否为一个质数
boolean flag = true;
for (int j = 2; j < i; j++) {
//j表示2~99之间的每一个数字
if (i % j == 0) {
flag = false;
//跳出单层循环，内循环
break;
}
}
if (flag) {
System.out.println("当前数字" + i + "是质数");
count++;
}
}
System.out.println("一共有" + count + "个质数");
}
}
3.3 开发验证码
随机生成5位验证码，前四位是大小写字母，最后一位是数字
import java.util.Random;
public class Main {
public static void main(String[] args) {
//开发验证码
char [] yzm = new char[5];
Random r = new Random();
for(int i = 0;i<=3;i++)
{
yzm[i] = (char)(r.nextBoolean()?r.nextInt(65,91):r.nextInt(97,123));
}
yzm[4] = (char)(r.nextInt(48,58));
for(int i = 0;i<yzm.length;i++)
{
System.out.print(yzm[i]);
}
}
}
3.4 数值元素的复制
把一个数组复制到新数组中
public class Main {
public static void main(String[] args) {
/*需求:
把一个数组中的元素复制到另一个新数组中去。*/
//分析:
//1.定义一个老数组并存储一些元素
int[] arr = {1,2,3,4,5};
//2.定义一个新数组的长度跟老数组- -致
int[] newArr = new int[arr.length];
//3.遍历老数组，得到老数组中的每一一个元素， 依次存入到新数组当中
for (int i = 0; i < arr.length; i++) {
//i表示老数组中的索引。新数组中的每一一个索引
//arr[i]表示 老数组中的元素
newArr[i] = arr[i];
}
//4.新数组中已经存满元素了
for (int i = 0; i < newArr.length; i++) {
System.out .print(newArr[i]);
}
}
}
3.5 评委打分
需求:
在唱歌比赛中，有6名评委给选手打分,分数范围是[0 - 100]之间的整数。选手的最后得分为:去掉最
高分、最低分后的4个评委的平均分，请完成.上述过程并计算出选手的得分。
package com.mochu.project1;
import java.util.Scanner;
public class JudgeScore {
public static void main(String[] args) {
// 定义一个动态数组存储六位评委的分数
int[] scores = new int[6];
Scanner sc = new Scanner(System.in);
for (int i = 0; i < scores.length; i++) {
System.out.print("请输入第" + (i + 1) + "位评委的分数：");
int score = sc.nextInt();
scores[i] = score;
}
int max = scores[0];
int min = scores[0];
int sum = 0;
for (int i = 0; i < scores.length; i++) {
if(scores[i] > max) {
max = scores[i];
}
if(scores[i] < min) {
min = scores[i];
}
sum += scores[i];
}
double result = (sum - max - min) * 1.0 / (scores.length - 2);
System.out.println("选手最终得分是：" + result);
}
}
3.6 数学加密和解密
package com.mochu.project1;
import java.util.Scanner;
public class NumberEncrypt {
public static void main(String[] args) {
System.out.print("请输入需要加密的数字个数：");
Scanner sc = new Scanner(System.in);
int length = sc.nextInt();
int[] arr = new int[length];
// 录入数组元素
for (int i = 0; i < arr.length; i++) {
System.out.print("请输入第" + (i + 1) + "位数字：");
int number = sc.nextInt();
arr[i] = number;
}
printArray(arr); // 打印数组
// 数字加密
for (int i = 0; i < arr.length; i++) {
arr[i] = (arr[i] + 5) % 10;
}
// 数组反转（逆序）
for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
int temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
printArray(arr);
}
// 打印数组的方法
public static void printArray(int[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ", ");
}
System.out.println("]");
}
}
3.7 抽奖的两种实现方式
import java.util.Random;
public class Main {
public static void main(String[] args) {
int [] chi = {2,588,888,1000,10000};
Random r = new Random();
int [] chi2= new int[chi.length];
int i = chi.length;
while(i>0)
{
int temp = r.nextInt(0,5);
boolean flag = true;
for(int j = 0;j<chi2.length-i+1;j++)
{
if(chi2[j]==chi[temp])
{
flag = false;
break;
}
}
if(flag==true)
{
System.out.println(chi[temp]+"被取出");
chi2[chi2.length-i]=chi[temp];
i--;
}
}
}
}
3.8 双色球彩票系统
package com.mochu.project1;
import java.util.Random;
import java.util.Scanner;
public class DoubleColorBall {
public static void main(String[] args) {
// 随机生成6个红球号码(1-33，不能重复)，随机一个蓝球号码(1-16)，采用数组将中奖号码封装起来。
int[] lucknumbers = createLuckyNumber();
// 用户输入七个双色球号码，作为用户选号
int[] inputnumbers = userInputNumbers();
judge(lucknumbers, inputnumbers);
}
// 判断中奖，判断红球、蓝球分别中了多少个数
public static void judge(int[] lucknumbers, int[] inputnumbers){
int redballcount = 0;
int blueballcount = 0;
// 统计红球中了多少个
for (int i = 0; i < inputnumbers.length - 1; i++) {
for (int j = 0; j < lucknumbers.length - 1; j++) {
if(inputnumbers[i] == lucknumbers[j]) {
redballcount++;
break;
}
}
}
// 统计蓝球中了没中
blueballcount = inputnumbers[inputnumbers.length - 1] == lucknumbers[lucknumbers.length - 1] ? 1 : 0;
System.out.println("您的号码是：");
printArray(inputnumbers);
System.out.println("中奖号码是：");
printArray(lucknumbers);
System.out.println("您命中了" + redballcount + "个红球");
System.out.println("您" + (blueballcount == 1 ? "命中了" : "没有命中") + "蓝球");
// 判断奖励情况
if(blueballcount == 1 && redballcount < 3) {
System.out.println("恭喜您！，获得5元奖励~");
}else if(blueballcount == 1 && redballcount == 3 || blueballcount == 0 && redballcount == 4) {
System.out.println("恭喜您！获得10元奖励~");
}else if(blueballcount == 1 && redballcount == 4 || blueballcount == 0 && redballcount == 5) {
System.out.println("恭喜您！获得200元奖励~");
}else if(blueballcount == 1 && redballcount == 5) {
System.out.println("恭喜您！获得3000元奖励~");
}else if(blueballcount == 0 && redballcount == 6) {
System.out.println("恭喜您！获得500万奖励~");
}else if(blueballcount == 1 && redballcount == 6) {
System.out.println("恭喜您！获得1000万奖励~");
}else {
System.out.println("很遗憾，您没有获奖");
}
}
// 录入用户生成号码
public static int[] userInputNumbers() {
int[] inputNumbers = new int[7];
Scanner sc = new Scanner(System.in);
for (int i = 0; i < inputNumbers.length - 1; i++) {
System.out.print("请输入第" + (i + 1) + "个红球号码（1-33，要求不重复）：");
inputNumbers[i] = sc.nextInt();
}
System.out.print("请输入篮球号码（1-16，要求不重复）：");
inputNumbers[inputNumbers.length - 1] = sc.nextInt();
return inputNumbers;
}
// 生成中奖号码
public static int[] createLuckyNumber() {
int[] numbers = new int[7];
// 6个不重复的红球号码(1-33)
Random rd = new Random();
for (int i = 0; i < numbers.length - 1; i++) {
// 需要判断当前这个随即号码之前是否出现过，如果出现过则需要重新生成一个号码直到不重复为止。
while (true) {
int data = rd.nextInt(33) + 1;
boolean flag = true;
for (int j = 0; j < i; j++) {
if(numbers[j] == data) {
flag = false;
break;
}
}
if(flag) {
numbers[i] = data;
break;
}
}
}
// 生成蓝球号码(1-16)
numbers[numbers.length - 1] = rd.nextInt(16) + 1;
return numbers;
}
// 遍历数组
public static void printArray(int[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
System.out.print(i == arr.length -1 ? arr[i] : arr[i] + ", ");
}
System.out.println("]");
}
}
3.9 二维数组
什么是二维数组？数组中存数组
当我们需要把数据分组管理的时候，就需要用到二维数组
二维数组的静态初始化
●格式:数据类型 [][] 数组名 = new 数据类型[][] {{元素1,元素2},{元素1,元素2}};
●范例: int[][] arr = new int[][]{11,22},{33,44};
简化格式:数据类型[][]数组名= {{元素1,元素2}, {元素1,元素2}};
public class Main {
public static void main(String[] args) {
//静态初始化 可以长度不等
int [][] arr= new int[][]{{1,2,3},{4,5,6,7,8,9}};
int [][] arr1= {{1,2,3},{4,5,6,7,8,9}};
//以后建议这样定义
int [][] arr2={
{1,2,3},
{4,5,6,7,8,9}
};
//2.获取元素
System.out.println(arr2[0]);//[I@7ef20235 现在获取的是第一个一维数组 还是地址。
System.out.println(arr2[0][0]);//1
}
}
public class Main {
public static void main(String[] args) {
//静态初始化 可以长度不等
int [][] arr= new int[][]{{1,2,3},{4,5,6,7,8,9}};
int [][] arr1= {{1,2,3},{4,5,6,7,8,9}};
//以后建议这样定义
int [][] arr2={
{1,2,3},
{4,5,6,7,8,9}
};
//3、二维数组遍历
for (int i = 0; i < arr2.length ; i++) {
//i:表示二维数组中的每一个索引
//arr3[i]:表示二维数组中的每一一个元素 (一维数组)
for(int j=0;j < arr2[i].length ; j++){
//j:表示一维数组中的每一个元素
System.out.println(arr2[i][j]);
}
}
}
}
二维数组的动态初始化
●格式: 数据类型[][]数组名= new数据类型[m][n];
m表示这个二维数组，可以存放多少个一维数组
n表示每一个一维数组，可以存放多少个元素
public class Main {
public static void main(String[] args) {
//静态初始化 可以长度不等
int [][] arr= new int[3][5];
arr[0][1] = 10;
for (int i = 0; i < arr.length; i++) {
for (int i1 = 0; i1 < arr[i].length; i1++) {
System.out.print(arr[i][i1]+" ");
}
System.out.println();
}
}
}
没用的数组变垃圾
public class Main {
public static void main(String[] args) {
/*某商城每个季度的营业额如下:单位(万元)
第一季度: 22,66,44
*维数组
第二季度: 77,33,88
*维数组
第三季度: 25,45,65
*维数组
第四季度: 11,66,99
一维数组
要求计算出每个季度的总营业额和全年的总营业额*/
//1.创建二维数组并存储数据
int [][] arr = {
{22,66,44},
{77,33,88},
{25,45,65},
{11,66,99}
};
int b = 0;
for (int i = 0; i < arr.length; i++) {
int a = 0;
for (int i1 = 0; i1 < arr[i].length; i1++) {
a = a +arr[i][i1];
}
System.out.println(a);
b= b+a;
a = 0;
}
System.out.println(b);
}
}