2.创建类MyDate,year属性和month属性,编写一个方法totalDays,该方法通过年份和月份判断该月一共有多少天,在主函数中接受用户输入年和月，调用该方法测试它.
这里考虑平年和闰年
“平年2月有28天。闰年的2月有29天
那么就有区别了
只要判断这一点就行了！！！
1 3 5 7 8 10 12:31天
4 6 9 11:30天
这里还是用数组存储好一点
然后就是返回值的问题
创建一个图形类。可以根据指定的符号，打印正方形。通过组建类来完成这一功能;
- 定义一个Figure类
- 定义一个inChar 内部字符属性
- 定义一个String showFigure() 返回图形字符串方法
public class Figure {
private char inChar; // 内部字符public Figure(char inChar) {
this.inChar = inChar;
}public void showFigure(int sideLength) {
String figure = "";for (int i = 0; i < sideLength; i++) {
for (int j = 0; j < sideLength; j++) {
figure += inChar;
}
figure += "\n";
}System.out.println(figure);
}public static void main(String[] args) {
Figure square = new Figure('*');
square.showFigure(5);
}
}
创建一个银行类，用于计算存款的利息，和本利合 .
利息的计算方法，年限小于一年的没有利息，1年以上的，利息为3%。
通过面向对象的方式来处理这个问题
分析：
- 定义一个Bank类
- 定义money属性
- 定义 double showInterest() 计算利息方法
- 定义 String showSumMoney() 显示信息方法
- 1000*0.3 = 300 1000+2(1000*0.03)
public class Bank {
private double money; // 存款金额public Bank(double money) {
this.money = money;
}public double showInterest() {
double interest = 0;
if (money >= 1000) {
interest = money * 0.03;
}
return interest;
}public String showSumMoney() {
double interest = showInterest();
double sumMoney = money + interest;
return "本金：" + money + "，利息：" + interest + "，本利合计：" + sumMoney;
}public static void main(String[] args) {
Bank bank = new Bank(1000);
System.out.println(bank.showSumMoney());
}
}
酒店管理系统
import javax.xml.transform.Source;
import java.util.Scanner;
/**
* 酒店管理系统
*/
public class HotelManagerSystem {
//全局变量, 整个类都有效
int[][][] rooms; //存储所有的房间信息
String[] roomTypeArr={"单人间","双人间","标准间","商务房","豪华包"};
int[] roomPriceArr={98,128,148,288,688};
//程序入口
public static void main(String[] args) {
//调用初始化方法
HotelManagerSystem sys = new HotelManagerSystem();
sys.initRoom(3,8);
//显示欢迎词
System.out.println("==============欢迎使用飞思酒店管理系统==============");
sys.showUI();
}
//显示菜单
public void showUI(){
System.out.println("1.查看房间;2.定房间;3.退房;4.修改价格;5.退出系统");
System.out.print("请选择您需要的服务:");
Scanner input = new Scanner(System.in);
while(true){ //如果输入正确, 退出循环, 输入错误,继续循环
//数据校验: 非数字的校验
if(input.hasNextInt()){ //hasNextInt() 返回true: 输入的是一个数字, 否则不是
//得到选项
int choose = input.nextInt();
//System.out.println(choose);
if(choose >=1 && choose <=5){ //正确选项
//调用相对应服务
doService(choose); //处理用户选项
//退出循环
break;
}else{ //不是正确选项
//错误提示
System.out.println("【友情提示】:没有该选项!");
System.out.print("请重新输入:");
}
}else{
//错误提示
System.out.println("【友情提示】:输入选项格式错误!");
System.out.print("请重新输入:");
input.next();
}
}
}
/**
* 处理用户选项的服务
* @param choose
*/
public void doService(int choose) {
switch(choose){
case 1:
//查询房间
queryAllRoom();
break;
case 2:
//定房间
updateRoomState(true);
break;
case 3:
//退房
updateRoomState(false);
break;
case 4:
//修改房间价格
updateRoomPrice();
break;
case 5:
//退出
exitSystem();
break;
}
//回显菜单
showUI();
}
/**
* 修改同一类型的房间的价格
*/
public void updateRoomPrice() {
//1.显示所有的房间类型, 让用户选择需要修改的房间类型
System.out.println("房间类型:");
for (int i = 0; i < roomTypeArr.length ; i++) {
System.out.println("\t"+(i+1)+"."+roomTypeArr[i]);
}
System.out.print("请选择:");
Scanner input = new Scanner(System.in);
int choose = input.nextInt();
//2.根据房间类型得到下标
int index = choose - 1;
//3.修改价格数组对应的下标的值
System.out.print("请输入修改的价格:");
int price = input.nextInt();
roomPriceArr[index] =price;
System.out.println("修改房间价格成功!");
}
/**
* 订房或者退房
* true: 订房
* false: 退房
* @param flag
*/
public void updateRoomState(boolean flag) {
//1.直接让用户输入房间编号 -->得到楼层, 房间序号
Scanner input = new Scanner(System.in);
System.out.print("请输入您要订房/退房的房间编号:");
//数据校验
while(true){
if(input.hasNextInt()){
int roomNo = input.nextInt();
//得到楼层, 房间序号 108 --> 1 .8 120 --> 1 20
int floor = roomNo/100%10; //楼层
int index = roomNo%100; //房间序号
//输入的编号验证
if(floor<1 || floor > rooms.length ){
System.out.println("【友情提示】:没有该楼层!");
System.out.print("请重新输入:");
}else if(index < 1 || index > rooms[floor-1].length){
System.out.println("【友情提示】:没有该房间!");
System.out.print("请重新输入:");
}else{
//可以订房,或者退房
//System.out.println("可以订房,或者退房");
if(flag){ //true 订房
//判断状态
if(rooms[floor-1][index-1][2] == 0){ //空闲
//订房:
rooms[floor-1][index-1][2] = 1; //修改状态为1
System.out.println("恭喜您,订房成功!你的房间编号:"+roomNo);
//退出循环
break;
}else{
System.out.println("【友情提示】:该房间已被预订");
System.out.print("请重新输入:");
}
}else{
//判断状态
if(rooms[floor-1][index-1][2] == 1){ //有人
//退房:
rooms[floor-1][index-1][2] = 0; //修改状态为0
System.out.println("恭喜您,退房成功!");
//退出循环
break;
}else{
System.out.println("【友情提示】:该房间已退房!");
System.out.print("请重新输入:");
}
}
}
}else{ //非整数
System.out.println("【友情提示】:输入房间编号格式错误!");
System.out.print("请重新输入:");
input.next();
}
}
// 2.根据flag判断是否是定房还是退房: true: 订房 false: 退房
//3. 如果订房,先判断房间是空闲, 才允许订房, 如果有人, 让用户重新输入
//4. 如果退房, 先判断房间是有人, 才允许退房, 如果空闲, 让用户重新输入
}
/**
* 退出系统
*/
public void exitSystem() {
System.out.println("感谢使用本系统,欢迎下次使用!");
//系统退出
System.exit(0);
}
/**
* 查询所有房间信息
*/
public void queryAllRoom() {
System.out.println("酒店房间详情表:");
System.out.println("楼层\t房间号\t价格\t类型\t状态");
//循环遍历 rooms数组
// rooms.length: 获取三维数组包含二维数组个数, 有多少层
for (int i = 0; i < rooms.length ; i++) {
int floor = i+1;
//rooms[i].length 二维数组包含的一维数组个数 一层有多少个房间
for (int j = 0; j <rooms[i].length ; j++) {
//输出楼层
if(j == 0){ //楼层第一个房间
System.out.print(floor+"\t"); //打印楼层
}else{
System.out.print(" "+"\t"); //打印楼层
}
//j房间编号 房间编号: 三位数 百位: 楼层 后两位: 房间序号
int roomNo = floor*100+j+1;
System.out.print(roomNo+"\t");
//rooms[i][j].length 一维数组长度 每个房间的属性
for (int k = 0; k <rooms[i][j].length ; k++) {
switch (k){
case 0: //价格
System.out.print(roomPriceArr[rooms[i][j][0]]+"\t");
break;
case 1: //类型
System.out.print(roomTypeArr[rooms[i][j][1]]+"\t");
break;
case 2: //状态 0: 空闲, 1: 有人
// switch(rooms[i][j][2]){
// case 0:
// System.out.print("空闲");
// break;
// case 1:
// System.out.print("有人");
// break;
// }
System.out.println(rooms[i][j][2]==0?"空闲":"有人");
break;
}
}
}
//一个房间的信息输出完成, 换行
System.out.println();
}
}
/**
* 店房间进行初始化操作的方法
* @param n 有多少楼
* @param m 一楼有多少房间
*/
public void initRoom(int n, int m){
rooms = new int[n][m][3];
// n = rooms.length
// m = rooms[i].length
for (int i = 0; i <n ; i++) { //循环楼层
for (int j = 0; j < m; j++) { //某一楼的某个房间
// i = 0, j=0 表示 第一层第一个房间: 101
for (int k = 0; k <rooms[i][j].length ; k++) {
//给某个房间设置 价格, 类型, 状态
switch(k){
case 0: //设置价格 j%价格数组长度(5)求余 = 0~4
rooms[i][j][0]= j%roomPriceArr.length;
break;
case 1: //设置类型
rooms[i][j][1]= j%roomTypeArr.length;
break;
case 2: //设置状态 0: 空闲 1: 有人
rooms[i][j][2]=0;
break;
}
}
}
}
}
}
扩展: 选择排序, 插入排序, 每一种排序时间复杂度
int left = 0;
int right = arr.length - 1;
while(left < right){
int min = left;
int max = left;
for(int i = left;i <= right;i++){
if(arr[i] < arr[min]){
min = i;
}
if(arr[i] > arr[max]){
max= i;
}
}
swap(arr[left],arr[min]);
if(left == max){
max = min;
}
swap(right,max);
left++;
right--;
}
选择排序：O(n^2) 因为每一次遍历数组数组时，都要遍历数组选出最大和最小的数组，每一次遍历都是O(n),就算是自身有序的也要遍历筛选
int[] arr = {2,588,888,1000,10000};
if(arr.length <1){
return;//终止
}
for(int i = 1;i< arr.length;i++){
int index = arr[i];
int j;
//查找插入位置
for(j = i - 1;j >= 0;--j){
if(arr[j] > index){
arr[j+1] = arr[j];//数组整体移动
}else{
break;
}
}
arr[j+1] = index;
}
for(int v:arr){
System.out.print(v+"\t");
}
//时间复杂度：在完全有序的情况下，插入排序每个未排序区间元素只需要比较1次为O(n)
//极端情况下，比如数组时逆序排列分布，为O(n^2) 就等于每次把未排序元素插入到数组第一位。插入一个元素的时间复杂度为O(n) n个元素就是O(n^2)
int[] praise = {2,588,888,1000,10000};
int[] randomIndex = new int[5];
boolean[] generateNumbers = new boolean[5];设置一个布尔数组，初值全部设置为false,代表里面的元素->代表索引,用来解决重复问题
for(int i = 0;i <randomIndex.length;){
int index = (int)(Math.random()*randomIndex.length);
//一开始布尔索引里面放的全是false元素，给她加了索引(也没啥用还是false
// ,但是取反之后就为真了，，如果下次·是一样的生成的索引就会取反为false)
if (!generateNumbers[index]){
randomIndex[i] = index;
generateNumbers[index] = true;//generateNumber的索引应该也是随机的
i++;
}
}
for (int i = 0; i < praise.length; i++) {
System.out.println(praise[randomIndex[i]] + "的奖金被抽出");
} //1.声明数组
int[] arr1;
String arr2[];
char[] arr3;
//2.开辟空间
arr1 = new int[5];
System.out.println(arr1[0]);
//3.给数组添加元素
arr1[0] = 100;
//4.使用数组的元素
System.out.println(arr1[0]);
//声明开辟空间
String[] strs = new String[5];
System.out.println(strs[0]);
//静态初始化
int[] arr = new int[]{1,3,5,7,9};
String[] strs2 = {"张三","李四","王五"};
//分开
double[] arr2;
arr2 = new double[]{1.2,1.3,1.4};
//无法拆分
// char[] chArr;
//chArr = {'c','d','b'};
//给数组赋值
// arr2[3]=1.88;
// System.out.println(arr2[-1]);
//遍历数组
int[] ages = new int[10];
//循环赋值
Scanner input = new Scanner(System.in);
int sum = 0;
for (int i = 0; i <ages.length ; i++) {
System.out.print("请输入第"+(i+1)+"个学生的年龄:");
ages[i] = input.nextInt();
}
//求学生总年龄 5硬编码, 写死
for (int i = 0; i < ages.length ; i++) {
sum += ages[i];
}
//平均年龄
double avg = (double)sum / 5;
System.out.println("平均年龄:"+avg);
//---------------------------------------------------------------------------------------
int[] arr = {1,4,62,22,34,68,12,98,11};
//1.假设第一个元素是最大值
int max = arr[0];
int index = 0;//假设最大值的下标
//2.从数组第二个元素开始,依次与最大值比较,谁大谁就是最大
for (int i = 1; i < arr.length; i++) {
if(max < arr[i]){
max = arr[i];
index = i;
}
}
System.out.println("最大值:"+max);
System.out.println("最大值下标:"+index);## 数组
>存储数据
变量: 存储的一个值
int a = 10;
数组: 存储一组相同数据类型的值, 容器
变量要素:
1. 数据类型
2. 变量名
3. 变量的值
数组要素:
1. 数据类型
2. 数组名
3. 数组的下标: >=0 小于等于数组的长度-1
4. 数组的元素
使用变量:
1. 声明变量(开辟空间) int a;
2. 给变量赋值
3. 使用
使用数组:
1. 声明数组 语法: 数据类型[] 数组名; 数据类型 数组名[];
2. 开辟空间, 确定数组的长度(最多能存储几个元素)
语法: 数组名 = new 数据类型[长度];
数组有默认值元素:
>整数类型: 0
>
>浮点类型: 0.0
>
>char类型: \u000
>
>boolean类型: false
>
>String/类类型: null
3. 给数组添加元素 语法: 数组名[下标] = 值;
4. 获取数组的元素,使用 语法: 数组名[下标]
数组细节
-
声明与开辟空间合并
数据类型[] 数组名 = new 数据类型[长度];
-
静态赋值 声明,开辟空间, 添加元素合并
数据类型[] 数组名 = new 数据类型[]{值1,值2,…}
简写: 数据类型[] 数组名 ={值1,值2,…}
第一种写法: 声明数组与静态初始化可以拆分
第二种写法: 声明数组与静态初始化不可以拆分
-
数组下标问题 [0,数组长度-1]
手动给数组赋值,使用下标
获取数组的元素,使用下标
如果下标超出范围,抛如下错误
数组的特征: 固定长度,一旦数组确定长度,这个数组存储元素个数确定(缺点)
解决方案: 扩容(手动实现数组的扩容) 扩展作业
public class ArrayExpansion {
public static void main(String[] args) {
int[] originalArray = {1, 2, 3, 4, 5};
// 扩容为原数组长度的两倍
int[] expandedArray = new int[originalArray.length * 2];
// 复制原数组的元素到新数组中
for (int i = 0; i < originalArray.length; i++) {
expandedArray[i] = originalArray[i];
}
// 将新数组赋值给原数组引用
originalArray = expandedArray;
// 输出扩容后的数组
System.out.println("原始数组：" + Arrays.toString(originalArray));
}
}
-
数组的遍历, 与for匹配
数组属性: length属性: 数组的长度
数组名.length: 动态得到数组的长度
数组应用:
优化 找最大值/最小值
思路: 1. 假设第一个元素是最大/最小
在校足球联赛中,有5个班级的比赛积分如下表:
| 班级 | 积分 |
| 一班 | 15 |
| 二班 | 11 |
| 三班 | 13 |
| 四班 | 6 |
| 五班 | 9 |
分别使用冒泡排序和选择排序对5个班级的比赛积分进行降序排序
冒泡排序降序：
![学习babylon.js --- [4] 体验WebVR](https://img-blog.csdnimg.cn/87983d87a5a64db4980a90b371001d40.png)
