java面向对象编程基础
2025-03-11 本站作者 【 字体：大 中 小 】
int age;//声明变量，此时还未创建空间
age=19;//开辟空间并放入值
System.out.println(age);//从age的空间中取出值并输出到控制台
String name="王重阳";//声明并赋值
System.out.println("你好，我的名字叫："+name);//拼接字符串
三、java的运算符
算数运算符
+ - * / += -= % ++ --
示例：给一个3位的数，求个位数、十位数、百位数相加的和
int a=963;
int g=a%10;
int s=a/10%10;
int b=a/100;
System.out.println(g+s+b);
比较运算符(下一章再讲)
> , >= , < ,
强制类型转换其实就是欺骗编译器
我们强转之后 有可能会出现数据溢出的情况。
public static void main(String[] args){
short a=128;
byte b=(byte)a;
System.out.println(b);//结果是：-128
double c=56.9;
int d=(int)c;
System.out.println(d);//结果是：56
int e=20;
int f=3;
double g=a/b;
System.out.println(g);//结果是：6.0
}
为什么 a 和 b 相除的结果的类型是int类型呢？
原因是 java中变量的运算会自动提升：
两个变量运算 ，所得的结果类型 取决于参与运算变量的类型.
例如 a是int b 也是 int a和b进行运算结果 的类型要从a和b之中选一个。此时只有一种选择是 int 。
此时将a的类型改成 float b的类型还是 int ，结果的类型 就可以从 float 和 int之中选一个。此时结果类型选了float类型作为结果结果类型。（选取更精确的 所占字节大）
byte a=20;
short b=3;
int c=60;
float d=56.5f;
double e=a+b+c+d;
System.out.println(e);//结果是：6.0
编译器对数据类型和取值范围的判断
byte a=200;//错误，因为byte的取值范围是-128~127，常量整数默认为int类型
float d=56.5;//错误，因为默认情况下小数位double类型的，需要注明这个浮点数就是float类型
//--------下面两种就是正确的---------
byte a=127;
float d=56.5f;
为什么会报错呢？
因为 常量的整数，数据类型为 int ，常量的小数，数据类型为double。也就是说 200 这个数字 也有数据类型是 int。此时将int类型赋值给byte类型，是大给小，所以报错。同理 30.5的数据类型是double类型，double类型赋值给float也报错。所以我们的float在赋值的时候 需要加 F long类型赋值的时候需要加 L，F 和 L 可以理解成数据类型转换的特殊形式
下面的代码
此时 byte类型的a 赋值为127 此时不报错 为什么呢？
127是int类型 ，此时int类型的127 赋值给 byte类型的a 此时大给小不报错。原因是 编译器在预编译的时候，发现 127 是int 但是 在 byte的范围之内，所以将127给byte不会出现数据溢出的情况，此时编译器就隐式（偷偷地）将127的数据类型编程了 byte类型。
如果要进行基本的算术运算，则要求结果 的最低数据类型是整形（int）
short a=5;
short b=6;
short c=a+b;//a+b是int类型的，不能直接赋值给short类型，需要强制类型转换
short c=(short)(a+b);
不同种类型的要通过函数转换
String count="18";
int age=20;
System.out.println(count+age);//输出结果是1820，而不是38，这是因为这里的+号运算是将两个字符串进行了拼接
int ct=Integer.parseInt(count);
System.out.println(ct+age);//此时输出38；
基本类型包装类：
为了便于操作，java针对基本数据类型都有包装类，定义了很多便于操作的方法。
Byte byte;
Short short;
Integer int;
Long long;
Float float;
Double double;
Boolean boolean;
小结
算术运算的最小类型单位是int。
整数的除法结果是整形。
取值范围小的类型会自动转换为取值范围大的类型，反之则需要强制转换。
数值类型只要和字符串类型拼接（+），就可以转换为字符串类型。
字符串类型要转换成数值类型则必须使用数值类型的包装类的parse(字符串)方法。
第六节：控制台输入输出（重点） 一、格式输出
%s：字符串占位符
%d：整数占位符
%f：浮点数占位符
System.out.printf("我是%s，今年岁%d了,体重%.1f","王重阳",18,78.5);
二、接收键盘输入
Scanner扫描仪
创建对象：new Scanner(System.in);
public static void main(String[] args) {
System.out.println("请输入你的姓名：");
Scanner sc=new Scanner(System.in);
String name=sc.next();
System.out.println("请输入你的年龄：");
int age=sc.nextInt();
System.out.println("请输入你的体重：");
double weight=sc.nextDouble();
System.out.println("请输入你的爱好");
String hobby=sc.next();
System.out.printf("你的名字是：%s,今年%d岁了,体重是%.1f公斤，爱好是：%s",name,age,weight,hobby);
}
作业：类似上面的输入输出（10分钟）
请输入你要吃的菜名
请输入菜的价格
请输入菜的数量
输出：您点的？？？菜，？盘，单价是？？元，总金额是：？？元
第二章：流程控制 内容回顾：
java通过什么实现跨平台
java是诞生于美国哪所大学
java的基本数据类型有哪些
接收键盘输入的类是什么
本章内容： 第一节：程序结构
顺序结构
分支结构
循环结构
第二节：分支结构1：if-else
if(条件){
条件成立执行的代码
}else{
条件不成立执行的代码
public static void main(String[] args) {
System.out.println("亲输入你的存款");
Scanner sc=new Scanner(System.in);
double money=sc.nextDouble();
if(money>1000000) {
System.out.println("你是土豪");
}else {
System.out.println("你是屌丝");
}
}
多重if-else
请输入学生成绩，判断优良中差
System.out.println("亲输入你的成绩");
Scanner sc=new Scanner(System.in);
double score=sc.nextDouble();
if(score>=90) {
System.out.println("你是学霸");
}else if(score>=80) {
System.out.println("你是学酥");
}else {
System.out.println("你是学渣");
}
第二节：switch结构
switch(表达式){
case 1: 执行1后面的代码 break;
case 2 :执行1后面的代码 break;
case 3: 执行1后面的代码 break;
default:
}
使用switch判断学生成绩
System.out.println("亲输入你的成绩");
Scanner sc=new Scanner(System.in);
double score=sc.nextDouble();
switch((int)score/10) {
case 10:
case 9: System.out.println("优秀");break;
case 8: System.out.println("良好");break;
case 7: System.out.println("一般");break;
case 6: System.out.println("及格");break;
default: System.out.println("不及格");break;
}
判断月份的天数
public static void main(String[] args) {
System.out.println("亲输入年份");
Scanner sc=new Scanner(System.in);
double score=sc.nextDouble();
int year=sc.nextInt();
System.out.println("亲输入月份");
int month=sc.nextInt();
int mcount=31;
switch(month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12: mcount=31;break;
case 4:
case 6:
case 9:
case 11:mcount=30; break;
case 2:
if(year%4==0&&year%100!=0||year%400==0) {
mcount=29;
}else {
mcount=28;
}
}
System.out.printf("本月有%d天",mcount);
}
第三节：while循环
语法：
初始化变量
while（循环条件）{
循环体
改变变量
}
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("是不是要输入新的成绩");
String tiaojian=sc.next();
while(tiaojian.equals("是")) {
System.out.println("请输入郭大侠的比赛名次");
int lever=sc.nextInt();
switch(lever) {
case 1:System.out.println("武林盟主"); break;
case 2:System.out.println("武当掌门"); break;
case 3:System.out.println("峨眉掌门");break;
default: System.out.println("逐出师门");
}
System.out.println("是不是要输入新的成绩");
tiaojian=sc.next();
}
}
使用循环改造输入判断每月有多少天的代码
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String ans = "是";
while (ans.equals("是")) {
System.out.println("亲输入年份");
double score = sc.nextDouble();
int year = sc.nextInt();
System.out.println("亲输入月份");
int month = sc.nextInt();
int mcount = 31;
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
mcount = 31;
break;
case 4:
case 6:
case 9:
case 11:
mcount = 30;
break;
case 2:
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
mcount = 29;
} else {
mcount = 28;
}
}
System.out.printf("本月有%d天", mcount);
System.out.println("还要继续输入年月么？:是/否");
ans = sc.next();
}
}
使用while循环改造输入成绩判断优良的代码
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String ans = "是";
while (ans.equals("是")) {
System.out.println("亲输入你的成绩");
double score=sc.nextDouble();
switch((int)score/10) {
case 10:
case 9: System.out.println("优秀");break;
case 8: System.out.println("良好");break;
case 7: System.out.println("一般");break;
case 6: System.out.println("及格");break;
default: System.out.println("不及格");break;
}
System.out.println("还要继续输入年月么？:是/否");
ans = sc.next();
}
System.out.println("程序结束");
}
练习：本金存入1000元，年利率5%，问多少年后本金能超过5000元。
public static void main(String[] args) {
double money=1000;
double rate=0.05;
int i=0;
while(money<=5000) {
money=money+money*rate;
i++;
}
System.out.printf("本金是%.2f,年数是：%d",money,i);
}
示例2：小明要存钱，第一星期存1元，第二星期存2元，第三星期存4元，以后每星期都比上星期存的钱多一倍，问什么时候能存够1000元
double money=1;
int i=1;
double count=1;
while(money<1000) {
i++;//记录的星期数
count*=2;//每次存入的钱数
money+=count;//已经存入的金额
}
System.out.println(i+"星期后小明的钱能存到："+money+"元");
//暴力破解银行卡密码
int i=100000;
Random rand=new Random();//随机数类
int pass=rand.nextInt(999999);//生成一个0~999999之间的随机数
if(pass>=100000) {//如果产生的随机数超过6位，就把它当成银行密码
while(true) {//循环每次让i加一
if(pass==i) {//如果i的数和密码数相同，则跳出循环
break;
}
i++;//每次增加1
}
System.out.println("你的密码是："+i);
}
//输入一组成绩，中间用空格间隔，分别判断每个成绩的优良中差。
System.out.println("请输入一组成绩");
Scanner sc=new Scanner(System.in);
double score=0;
String level="";
while(sc.hasNextDouble()) {//判断是否还有下一个输入的成绩
score=sc.nextDouble(); //扫描得到下一个成绩
switch((int)score/10) {
case 10:
case 9:level="优秀";break;
case 8:level="良好";break;
case 7:level="中等";break;
case 6:level="及格";break;
default:level="不及格";
}
System.out.println(score+"分的等级是："+level);
}
System.out.println("成绩判断完毕");
控制台输入：55 66 77 88 99；
注意最后一定要加上分号 “；”，用来结束nextDouble();
第四节：do-while循环 第五节：for循环
语法：
for(初始化 ; 循环条件 ; 变量改变){ 循环体 }
//输出从1~100之间能被3整除的数
for(int i=1;i<=100;i++) {
if(i%3==0) {
System.out.println(i);
}
}
//从1累加到100
int sum=0;
for(int i=1;i<=100;i++) {
sum+=i;
}
System.out.println(sum);
//4、行酒令：明7暗7
for(int i=1;i<=100;i++) {
if(i%7==0||i%10==7||i/10==7) {
continue;
}
System.out.println(i);
}
//3、输出99乘法表
//1*3=3 2*3=6 3*3=9 //先找出每一行的规律
//1*4=4 2*4=8 3*4=12 4*4=16
for(int j=1;j<=9;j++) {
for(int i=1;i<=j;i++) {
System.out.print(i+"*"+j+"="+i*j+" ");
}
System.out.println();
}
2、判断一个数（例如7）是不是素数
int b=0;
for(int i=2;i<7;i++) {
if(7%i==0) {
b=1;
break;
}
}
if(b==0) {
System.out.print(7+" ");
}
输出从1~100之间的素数
for(int j=1;j<=100;j++) {
int b=0;//标记是不是被整除过，0：没被整除；1：被整除了
for(int i=2;i<j;i++) {//判断所给的数j是不是素数
if(j%i==0) {
b=1;
break;
}
}
if(b==0) {
System.out.print(j+" ");
}
}
作业：15分钟
1、输出从1~100之间的素数
2、行酒令：明7暗7
3、小明存钱：小明要存钱，第一星期存1元，第二星期存2元，第三星期存4元，以后每星期都比上星期存的钱多一倍，问什么时候能存够1000元
第三章：类和对象
回顾：while循环和for循环的区别
本章内容： 第一节：类和对象 一、什么是对象
就是世界万物的组成部分
对具体对象的共同特性进行抽象，形成的一个概念，叫做类
类是对象的抽象，对象是类的具体体现。
二、什么是面向对象编程
面向对象程序设计（英语：Object-oriented programming，缩写：OOP）是种具有对象概念的程序编程典范，同时也是一种程序开发的抽象方针。它可能包含数据、属性、代码与方法。对象则指的是类的实例。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性，对象里的程序可以访问及经常修改对象相关连的数据。在面向对象程序编程里，计算机程序会被设计成彼此相关的对象
我们之前说过 java是基于c++的一门面向对象语言。
面向对象是一种现在最为流行的程序设计方法，几乎现在的所有应用都以面向对象为主了，最早的面向对象的概念实际上是由IBM提出的，在70年代的Smaltalk语言之中进行了应用，后来根据面向对象的设计思路，才形成C++，而由C++产生了Java这门面向对象的编程语言。
但是在面向对象设计之前，广泛采用的是面向过程，面向过程只是针对于自己来解决问题。面向过程的操作是以程序的基本功能实现为主，实现之后就完成了，也不考虑修改的可能性，面向对象，更多的是要进行子模块化的设计，每一个模块都需要单独存在，并且可以被重复利用，增强可维护性，所以，面向对象的开发更像是一个具备标准的开发模式。
面向过程：c语言
在开发的时候，以程序的基本功能实现为主，不考虑后期的优化和维护
面向对象：Java c++ JavaScript
在开发的时候，不仅要考虑基本功能的实现，而且要考虑后期的优化和维护。
小结：
1 能理解的简单理解 不能理解拉到。因为面向对象的思想你不进行3年代码的实际开发 根本理解不了什么是面向对象。
2 就是想告诉你 面向对象可能在开发的时候 写的更麻烦了，但是后期优化的时候更方便。因为我们后面再去讲继承/多态/封装这些概念的时候，总有一些同学不理解。不理解的点在于为什么要这样做，我完全可以不用这样麻烦也能把功能实现？如果后面大家也有这样的疑问的时候，换个角度去思考，对比你的想法和老师的想法，试想一下：开发的时候功能有没有实现？后期改起来哪个更方便？
在面向对象定义之中，也规定了一些基本的特征：
（1）封装：保护内部的操作不被破坏；
（2）继承：在原本的基础之上继续进行扩充；
（3）多态：在一个指定的范围之内进行概念的转换。
面向对象的特征我们会单独的用几节课的时间讲解。
对于面向对象的开发来讲也分为三个过程：
OOA（面向对象分析）、OOD（面向对象设计）、OOP（面向对象编程）。
第二节：类的概念 一、什么是类
类是对具有相同属性的对象的一种抽象，它一般包括了属性和方法两大部分。可以理解为对象的设计图纸。
二、类的内容 三、类的定义
public class 类名{
属性
方法
public class Student {
String name;//存放姓名
String sex;//存放性别
int age;//存放年龄
double height;//存放身高
public void intro() {
System.out.printf("我是%s，性别：%s，年龄%d岁，身高%.2f米",name,sex,age,height);
}
public void eat(String food) {
System.out.println(name+"在吃"+food);
}
public void learn() {
System.out.println(name+"在学习java");
}
}
四、创建对象
Student stu=new Student();
五、访问对象中属性和方法
测试代码：
public static void main(String[] args) {
Student stu=new Student();
stu.name="刘旭晨";//访问对象中的属性是通过“.”操作符，相当于“的”
stu.sex="男";
stu.age=17;
stu.height=1.55;
stu.eat("王老五热干面");//访问对象中的方法也是通过“.”操作符
stu.intro();
stu.learn();
}
第三节：构造方法 1、语法：
public + 类名(参数列表){
//初始化属性
public Student(String name,String sex,int age,double height) {
this.name=name;
this.age=age;
this.sex=sex;
this.height=height;
}
public Student() {}
public Student(String name,String sex,int age) {
this.name=name;
this.age=age;
this.sex=sex;
}
使用构造方法
Student stu=new Student("刘旭晨","男",19,1.65);
构造方法小结： 第四节：定义一般方法
语法： public + 返回值类型 + 方法名(参数列表){方法体}
无返回值的方法
需要在修饰符后面，方法名前面标明void关键词，表示该方法没有返回值。
public void eat(String food) {
System.out.println(name+"在吃"+food);
}
带返回值的的方法
需要在修饰符后面，方法名前面标明返回值的类型
public String buy(double money) {
if(money<=1.5) {
return "矿泉水";//返回的具体值必须是定义的类型的值
}else {
return "方便面";
}
}
带返回值的方法的调用
需要声明一个相同类型的变量来接受方法的返回值
String res=stu.buy(5.5);
System.out.println(res);
类与对象是整个面向对象中最基础的组成单元。
类：是抽象的概念集合，表示的是一个共性的产物，类之中定义的是属性和行为（方法）；
对象：对象是一种个性的表示，表示一个独立的个体，每个对象拥有自己独立的属性，依靠属性值来区分不同对象。
可以一句话来总结出类和对象的区别：类是对象的模板，对象是类的实例。类只有通过对象才可以使用，而在开发之中应该先产生类，之后再产生对象。类不能直接使用，对象是可以直接使用的。
作业：类似代码12分钟
编写狗（Dog）类
属性：名字
颜色
品种
年龄
方法：
展示-display：输出小狗的所有属性
吃eat，没有返回值，根据传入的参数输出“XXX小狗正在吃XXX”
看门-guard，有返回值，根据传入的进门的人的不同返回不同的结果，如果是生人，返回“旺旺”，如果是主人则返回“摇尾巴”
编写测试类，创建具体狗的对象，测试各个方法。
第五节：static关键词 static：静态的
用来修饰属性（成员变量），则该属性就成为类属性，所有该类的实例都共用这一个属性，任何一个实例改变了属性值，大家看到的都是修改过的值。在内存中static属性是所有类实例共有的内存地址。
public class Student {
String name;
int age;
static String className;
static double classMoney;
static {
System.out.println("这是静态块，加载就可以自动执行");
}
public void intro() {
System.out.println("我是"+name+",今年"+age+"岁了,我在"+
className+"班，有"+classMoney+"班费");
}
public static void showClassInfo() {
System.out.println(className+"班有"+classMoney+"元班费");
}
public void buy(double money) {
classMoney-=money;
}
}
用来修饰方法，则该方法是静态方法，静态方法只能访问静态属性（变量），不能访问一般的成员变量。
静态的属性和方法都可以通过类名加"."直接访问。
静态块：在类加载时自动调用
一般方法既可以访问一般属性（变量），也可以访问静态属性（变量）
测试类：
public static void main(String[] arg) {
Student.className="javaA255";
Student.classMoney=987.9;
Student stu1=new Student("王逗逗",19);
Student stu2=new Student("李四光",17);
stu1.intro();
stu1.className="A356";
stu1.buy(4.9);
stu2.intro();
stu2.showClassInfo();
}
示例：售票员
public class Ticker {
String name;
static int tickCount=9;
public Ticker(String name){
this.name=name;
}
public void soldTick(){
tickCount--;
System.out.println(name +"卖了一张票");
System.out.println(name +"还剩余"+tickCount+"张票");
}
}
测试类代码：
public static void main(String[] args) {
Ticker tic1=new Ticker("江永梅");
Ticker tic2=new Ticker("王琼");
Ticker tic3=new Ticker("赖培婷");
tic1.soldTick();
tic2.soldTick();
tic3.soldTick();
}
第四章：常用类： 第一节：String
split：按照指定规则将字符串拆分成数组
subString(begin,engin)：获取两个索引之间的子串
replace(“要替换的子串”,”替换成的子串”)
String a=new String("abcd");//创建了两个String实例
String b="abc";//常用的创建String方法
int c=9;
String d=String.valueOf(c);//""+c;
String id="454150199608121256";
System.out.println(id.subString(6, 10)+"-"+id.substring(10,12)+"-"+id.substring(12,14));
替换中间的间隔符
String str="System-out-print";
System.out.println(str.replace("-",""));
输出结果是：Systemoutprint
将样式表中的属性转换成驼峰命名的属性名-1
String str="border-right-color";
String[] sss=str.split("-");
String result="";
result+=sss[0];
for(int i=1;i<sss.length;i++) {
String f=sss[i];
String first=f.substring(0, 1);
String end=f.substring(1);
String up=first.toUpperCase();
System.out.println(up);
System.out.println(end);
System.out.println(up+end);
result+=(up+end);
}
System.out.println(result);
将样式属性改成驼峰命名规则命名-2
String str="border-right-color-hte-data";
String[] sss=str.split("-");//将给定的字符串，按照“-”进行拆分成单词数组
String result=sss[0];//将数组中第一个单词赋值给结果字符串
for(int i=1;i<sss.length;i++) {
String first=sss[i].substring(0,1);//截取第一个字母
String up=first.toUpperCase();//将第一个字母转换成大写
String end=sss[i].substring(1);//截取首字母后面的所有子串
result+=up+end;//将大写的首字母和后面的子串拼接后串联到结果字符串
}
System.out.println(result);
第二节：StringBuilder和StringBuffer
一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作
StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。
String a="abcde";
String b="defg";
String c=a+b;
StringBuilder sb=new StringBuilder("abc");
StringBuilder sb1=sb.append(b);
sb1.insert(3, "1234");
System.out.println(sb1);
System.out.println(sb1.reverse());
//sb.append(b).insert(3, "6789").reverse();
求1~10000以内的回文数
for(int i=1;i<10000;i++) {
StringBuilder sb = new StringBuilder("");
sb.append(i);//将数字拼接字符串
String old = sb.toString();//获取StringBuilder中的字符串原值
if (old.equals(sb.reverse().toString())) {//将原值和反转后的字符串原值进行比较
System.out.print(old+"\t");
}
}
第三节：日期及格式化
日期格式字符串
y ：代表年
M ：代表月
d： 代表日
E： 代表星期
H ：代表24进制的小时
h ：代表12进制的小时
m： 代表分钟
s ：代表秒
S ：代表毫秒
java.util.Date;
java.sql.Date;
java.time.LocalDate
输出当前系统时间为汉语格式
Date d=new Date();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss");
System.out.println(d);
System.out.println(sdf.format(d));
LocalDate使用
LocalDate ld=LocalDate.now();
Date date=Date.valueOf(ld);
System.out.println("localDate="+ld);
System.out.println("sqlDate="+date);
LocalDate ld2=LocalDate.parse("2020-04-06");
DateTimeFormatter formatter=DateTimeFormatter.ofPattern("yy/MM/dd");
System.out.println(ld.format(formatter));
System.out.println(ld.getYear());
System.out.println(ld.getMonthValue());
System.out.println(ld.getDayOfMonth());
System.out.println(ld.getDayOfWeek());
计算时间的差值：Duration.between()
public static void main(String[] args) throws ParseException {
LocalDateTime ldt=LocalDateTime.now();
LocalDateTime paldt=LocalDateTime.parse("1996-10-25T12:15:23.236");
Duration dt=Duration.between(paldt,ldt);
System.out.println(dt.toDays()/365);
System.out.println(dt.toHours());
System.out.println(dt.toMinutes());
System.out.println(dt.getSeconds());
}
解析字符串为Date对象
public static void main(String[] args) throws ParseException {
Date d=new Date();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss");
System.out.println(d);
System.out.println(sdf.format(d));
String dstr="1999年12月22日 12:23:45";
Date dd=sdf.parse(dstr);
System.out.println(dd);
String id="415254199811250159";
SimpleDateFormat sd=new SimpleDateFormat("yyyyMMdd");
System.out.println(sd.parse(id.substring(6,14)));
}
作业：（15分钟）
给一个CSS样式属性字符串，要求输出驼峰格式的名称；
给一个身份证号码，要求输出这个人的生日（格式为：yyyy年MM月dd日）,并计算这个人的年龄。
第五章：数组操作 回顾：
SimpleDateFormat sdf=new SimpleDateFormat();
Date date=new Date();
System.out.println(sdf.format(date);
本章内容： 第一节：数组的定义和访问
1、数组的定义
int[] arrs=new int[5];
int arr1[]= {4,6,7,9,0,2};
String[] sr=new String[] {"a","b","c"};
2、数组的访问
异常：ArrayIndexOutOfBoundsException
arrs[0]=5;
arrs[1]=9;
//arrs[6]=90;//抛出ArrayIndexOutOfBoundsException异常
System.out.println(arr1[2]);
for(int i=0;i<arr1.length;i++) {
System.out.println(arr1[i]);
}
第二节：数组的排序（重点）
冒泡排序：
int arr[]= {90,34,32,56,21,71,4,86,7,11};
for(int i=1;i<arr.length;i++) {//i为比较的轮数
for(int j=0;j<arr.length-i;j++) {//每一轮比较的最后一个元素已经是最大的值了，不需要再参与比较
if(arr[j]>arr[j+1]) {//如果前一个元素比后一个元素大，则交换两个元素的位置
int temp=arr[j];//将前一个元素放到一个临时的位置
arr[j]=arr[j+1];//将后一个元素放到前一个元素的位置
arr[j+1]=temp;//将放到临时位置的前一个元素放到后一个元素的位置
}
}
for(int k=0;k<arr.length;k++) {
System.out.print(arr[k]+"\t");
}
System.out.println();
}
int[] arr= {8,9,5,7,3,0};
Arrays.sort(arr);
for(int i=0;i<arr.length;i++) {
System.out.print(arr[i]+"\t");
}
选择排序：
public static void main(String[] args) {
int[] arr={90,34,32,56,21,71,4,86,7,11};
int temp,index=0;
for(int j=0;j<arr.length-1;j++) {
index=j;//标记每一轮最小的擂台位置为本次的起始位置
for (int i = j+1; i < arr.length; i++) {//将首位以后的每个元素和首位元素进行比较
if (arr[index] > arr[i]) {
index = i;//如果有比标记的擂台位置的值小，则把小的位置作为擂台标记出来
}
}
if (index != j) {//如果index被标记（有比擂台值小的元素），则将最小的元素和擂台标记的起始位置元素进行交换
temp = arr[index];
arr[index] = arr[j];
arr[j]=temp;
}
}
}
第三节：二维数组（了解）
定义二维数组：
int[][] arrs=new int[4][3];
访问二维数组：
int[][] arrs= { {1,2,3},{4,5,6},{7,8,9},{0,10,11}};//new int[4][3];
for(int i=0;i<arrs.length;i++) {
int[] subArr=arrs[i];
for(int j=0;j<subArr.length;j++) {
System.out.print(subArr[j]+"\t");
}
System.out.println();
}
第四节：对象数组（重点）
创建Student类中的toString方法
public class Student {
String name;
String sex;
int age=19;
public Student(String name,String sex,int age) {
this.name=name;
this.sex=sex;
this.age=age;
}
public String toString() {//toString方法是原有的方法，当直接打印该对象时就会执行该方法
return name+":"+sex+":"+age;
}
}
创建Student数组，并将Student对象放入到数组中
public static void main(String[] args) throws ParseException {
Student[] stus=new Student[5];
Student stu1=new Student("唐玄宗","男",800);
Student stu2=new Student("孙悟空","男",500);
Student stu3=new Student("猪无能","男",1000);
Student stu4=new Student("沙悟净","男",900);
Student stu5=new Student("小白龙","男",400);
stus[0]=stu1;
stus[1]=stu2;
stus[2]=stu3;
stus[3]=stu4;
stus[4]=stu5;
for(int i=0;i<stus.length;i++) {
System.out.println(stus[i]);
}
}
学生对象数组的排序
public static void main(String[] args) throws ParseException {
Student[] stus=new Student[5];
Student stu1=new Student("唐玄宗","男",800);
Student stu2=new Student("孙悟空","男",500);
Student stu3=new Student("猪无能","男",1000);
Student stu4=new Student("沙悟净","男",900);
Student stu5=new Student("小白龙","男",400);
stus[0]=stu1;
stus[1]=stu2;
stus[2]=stu3;
stus[3]=stu4;
stus[4]=stu5;
for(int j=1;j<stus.length;j++) {
for(int i=0;i<stus.length-j;i++) {
if(stus[i].age<stus[i+1].age) {
Student st=stus[i];
stus[i]=stus[i+1];
stus[i+1]=st;
}
}
}
for(int i=0;i<stus.length;i++) {
System.out.println(stus[i]);
}
}
作业：对象数组的冒泡排序和选择排序（12分钟） 下一章单词：
run：运行；show：展示；manager：管理者；add:增加；delete:删除；menu:菜单，目录；equals：等于；state：状态；price：价格；result：结果；find:查找；borrow：借出
第六章：共享汽车出租管理系统
第一节：创建Car实体类
该类用来存储每个汽车的具体信息
public class Car {
private String carno;//车牌号
private String carname;//汽车名称
private double price;//出租单价
private int status=1;//租借状态，1：未租；0：已租，默认：1
private LocalDateTime beginTime;//租借起始时间
private LocalDateTime endTime;//归还时间
public double account=0;//该车租金总和
public Car(String carno, String carname, double price) {
this.carno = carno;
this.carname = carname;
this.price = price;
}
public Car(String carno, String carname, double price, int status, LocalDateTime beginTime, LocalDateTime endTime) {
this.carno = carno;
this.carname = carname;
this.price = price;
this.status = status;
this.beginTime = beginTime;
this.endTime = endTime;
}
public Car() {
}
@Override
public String toString() {
return "Car{" +
"carno='" + carno + '\'' +
", carname='" + carname + '\'' +
", price=" + price +
", status=" + (status==0?"已租":"未租") +
", beginTime=" + beginTime +
", endTime=" + endTime +
", account=" + account +
'}';
}
//get/set方法
...
}
第二节：创建CarDB类
该类是一个Car的数组，用来存储出租车辆的信息，相当于数据库，里面的cararr和carCount都是静态的，是共享信息，不能创建实例。
public class CarDB {
public static Car[] cararr=new Car[50];//存储车辆信息的仓库
public static int carCount=8;//目前拥有的汽车数量
static{//静态块，添加默认信息
cararr[0]=new Car("京666D7M","途观",40);
cararr[1]=new Car("京888D8M","路虎",60);
cararr[2]=new Car("京999D9M","长城",30);
cararr[3]=new Car("京555D0M","名爵",20);
cararr[4]=new Car("京678D1M","沃尔沃",55);
cararr[5]=new Car("京369D2M","高尔夫",45);
cararr[6]=new Car("京123D3M","宝马",35);
cararr[7]=new Car("京333D4M","凯迪拉克",80);
}
}
第四节：创建CarService类
该类是出租业务的各种方法，依赖于CarDB调用数据信息，里面有8种具体业务，和一个菜单
第一步：先将菜单方法完成，并添加8中业务方法的骨架，具体内容稍后再添加
package com.aaa;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.Scanner;
public class CarService {
private Car[] db =CarManager.cararr;
Scanner sc=new Scanner(System.in);
public void menu() {
System.out.println("欢迎使用共享汽车管理系统");
System.out.println("----------------------------------");
System.out.print("1:展示汽车\t");
System.out.print("2:查找汽车\t");
System.out.print("3:借出汽车\t");
System.out.print("4:归还汽车\t");
System.out.print("5:新增汽车\t");
System.out.print("6:删除汽车\t");
System.out.print("7:查看营收\t");
System.out.print("8:营收排行\t");
System.out.println("9:退出汽车管理系统");
System.out.println("----------------------------------");
}
public void searchCar(){ System.out.println("模糊查找的车辆信息"); }
public void showCar() { System.out.println("展示汽车信息"); }
public void borrowCar() { System.out.println("租借汽车"); }
public void backCar() { System.out.println("归还汽车"); }
public void addCar() { System.out.println("新增汽车"); }
public void delCar(){ System.out.println("报废汽车"); }
public void showAccount() { System.out.println("总营收展示"); }
public void sortAccount(){ System.out.println("各汽车营收排行"); }
}
第五节：系统运行主类CarMain
该类依赖CarService类，根据用户的选择来调用其中各种业务方法
package com.aaa;
public class CarMain {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
CarService cs=new CarService();
int opt=0;
while(true){
cs.menu();
System.out.println("请选择你的操作");
opt=sc.nextInt();
switch(opt){
case 1:
cs.showCar();
break;
case 2:
cs.searchCar();
break;
case 3:
cs.borrowCar();
break;
case 4:
cs.backCar();
break;
case 5:
cs.addCar();
break;
case 6:
cs.delCar();
break;
case 7:
cs.showAccount();
break;
case 8:
cs.sortAccount();
break;
case 9:
System.out.println("您已经退出系统");
return;
default:
System.out.println("请选择1~9的功能");
}
}
}
}
第六节：实现展示、查找业务
CarService类中给具体业务方法增加内容
private int findCar(String carNo){//返回给定车牌号的车辆位置
for(int i=0;i第七节：实现出借汽车业务
public void borrowCar() {
System.out.println("请输入要租借的汽车的号码");
String carNo=sc.next();
int index=findCar(carNo);
if(index==-1){
System.out.println("没有你要找的汽车");
}else{
if(db[index].getStatus()==1){
db[index].setBeginTime(LocalDateTime.now());
db[index].setStatus(0);
System.out.println(db[index].getCarname()+"已经出租");
}else{
System.out.println("您要租的车还没有归还");
}
}
}
第八节：实现归还业务
归还车辆时要根据出借和归还时间的时间差来计算租车费用，
这里使用Duration.between(beginTime , endTime)
public void backCar() {
System.out.println("请输入要归还的汽车的号码");
String carNo=sc.next();
int index=findCar(carNo);
if(index==-1){
System.out.println("没有你要归还的汽车");
}else{
if(db[index].getStatus()==1){
System.out.println("这辆汽车还没出借无法归还");
}else{
db[index].setEndTime(LocalDateTime.now());
db[index].setStatus(1);
Duration da=Duration.between(db[index].getBeginTime(),
db[index].getEndTime());
long time=da.getSeconds();
System.out.println("您需要支付："+time*db[index].getPrice()+"元租车费");
db[index].account+=time*db[index].getPrice();
System.out.println(db[index].getCarname()+"归还完毕" );
}
}
}
第九节：实现新增和报废车辆的业务方法
1、将新增车辆信息放到数组所有车辆的最后：db[CarManager.carCount]，然后让CarManager.carCount++；
public void addCar() {
System.out.println("请输入新增汽车名称：");
String carName=sc.next();
System.out.println("请输入新增汽车牌号：");
String carNo=sc.next();
System.out.println("请输入新增汽车出租单价：");
double price=sc.nextDouble();
Car car=new Car(carNo,carName,price);
db[CarManager.carCount]=car;
CarManager.carCount++;
}
2、编写报废车辆方法的主代码：找到合适的车辆的位置，将该位置后面的车辆逐个前移，将CarManager.carCount–;
public void delCar(){
System.out.println("请输入要报废汽车的车牌号");
String carno=sc.next();
int index=findCar(carno);
if(index==-1){
System.out.println("没有找到这辆车");
}else {
if(db[index].getStatus()==0){
System.out.println("汽车尚未归还，不能报废");
}else{
for(int i=index;i第十节：实现营收统计和排行
public void showAccount() {//加和所有的车辆营收金额
double sum=0;
for(int i=0;i db[index].getEndTime());
long time=da.getSeconds();
System.out.println("您需要支付："+time*db[index].getPrice()+"元租车费");
db[index].account+=time*db[index].getPrice();
System.out.println(db[index].getCarname()+"归还完毕" );
}
}
}
### 第九节：实现新增和报废车辆的业务方法
1、将新增车辆信息放到数组所有车辆的最后：db[CarManager.carCount]，然后让CarManager.carCount++；
public void addCar() {
System.out.println(“请输入新增汽车名称：”);
String carName=sc.next();
System.out.println(“请输入新增汽车牌号：”);
String carNo=sc.next();
System.out.println(“请输入新增汽车出租单价：”);
double price=sc.nextDouble();
Car car=new Car(carNo,carName,price);
db[CarManager.carCount]=car;
CarManager.carCount++;
2、编写报废车辆方法的主代码：找到合适的车辆的位置，将该位置后面的车辆逐个前移，将CarManager.carCount--;
public void delCar(){
System.out.println("请输入要报废汽车的车牌号");
String carno=sc.next();
int index=findCar(carno);
if(index==-1){
System.out.println("没有找到这辆车");
}else {
if(db[index].getStatus()==0){
System.out.println("汽车尚未归还，不能报废");
}else{
for(int i=index;i
第十节：实现营收统计和排行
public void showAccount() {//加和所有的车辆营收金额
double sum=0;
for(int i=0;i sum+=db[i].account;
System.out.println(“总营收为：”+sum);
public void sortAccount(){//使用冒泡排序法对车辆营收从高到低排列
Car temp;
for(int j=1;j
猜你喜欢
天津限号9月查询（时间+区域+规则）
184 内燃机的制作方法
195 Jeep终于出了7座SUV，实力不俗，汉兰达要小心了！
153 初次申领机动车驾驶证有效期
295 竹叶山二手车市场2期盛大开业
169 宝马840i敞篷跑车
130 趣味剖析现代汽车集团E-GMP平台，它到底有何硬实力？
97 别人家遛狗，黄岩大叔却是遛机器人！用处可大，还能独自出门买菜、买早餐
115 万达长白山国际度假区诚挚欢迎您的到来！
127 累死我了，从1楼爬到28楼，终于找到哪层最吵了
160 
