java面向对象编程基础

Dear 丶 2022-11-11 13:10 297阅读 0赞

# java面向对象编程基础 #

## 前言：什么是java ##

*  是咖啡飘香的清晨

![\-][-]\- 是斯坦福校园意浓情深  
![\-][- 1]\- 是James的思想睿智  
![\-][- 2]

*  是剁手党双十一挥舞的利刃
 *  ![img][]
 *  是大数据云计算驰骋的平台  
    ![\-][- 3]\- 是ATM上吐出的钞票  
    ![\-][- 4]\- 是Android手机游走的灵魂  
    ![\-][- 5]
 *  啊！java我的神  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA_size_16_color_FFFFFF_t_70]

### 课程内容： ###

*  Java的基础知识
 *  Java流程控制语句
 *  Java常用包和类
 *  数组操作
 *  面向对象的概念
 *  异常处理
 *  文件访问
 *  数据集合操作
 *  JDBC访问数据库

### 课程目标： ###

掌握面向对象编程的基本思想和技能

## 第一章：java入门 ##

#### 本章内容 ####

1.  java语言简介
2.  JDK安装和配置
3.  java运行原理
4.  Hello World
5.  java的数据类型、变量、运算符
6.  控制台的输入输出

#### java学习的思路 ####

Java和前端不同，前端的学习内容 能看到效果，我们开始学习的是java的语法。

看不见摸不着，但是需要我们记住。所以我们学习java很重要的一个事情就是背语法。此时很多人会出现一个问题，不理解。何为不理解 ：不知道为什么要这么做？Java语法的特殊性在于很长时间语法 到后面才会应用。我们学习的步骤 先记忆与法，然后在实际应用中去理解。

### 第一节：java简介 ###

#### java历史 ####

*  1996年，SUN公司发布了JDK1.0
 *  1998年，SUN公司发布了Java2平台
 *  2000年，SUN公司发布了J2ME
 *  2001年1月，Java的企业版J2EE发布
 *  2004年8月， JDK1.5发布
 *  2010年10月，sun嫁给Oracle
 *  最新的JDK版本是JDK14

JDK最早是1.X版本，后来陆陆续续的升级 1.2 1.3 1.4 1.5 后来有一个划时代版本此时再以小版本命名就太low，从此就开始以大版本命名 JDK5 JDK6 JDK7 JDK8

\#\#\#\#java的基本概念

\#\#\#\#\#一、java平台：

###### JavaSE ######

Java Standard Edition 用于工作站，PC机的Java标准平台

###### JavaEE ######

Java Enterprise Edition可扩展的企业级应用Java平台

###### JavaME ######

Java Micro Edition用于嵌入式Java平台；

##### 二、java的特性 #####

开源具有面向对象、跨平台、简单性、解释执行、多线程、安全性等很多特点

##### 三、 JDK JRE JVM #####

JDK(Java Development Kit) 是 Java 语言的软件开发工具包。就是我们电脑如果要进行java语言的编写开发运行就需要安装JDK。

JRE是Java Runtime Environment缩写，指Java运行环境。JRE是JDK的一部分，意思就是说 安装完成JDK之后电脑上就有了JRE。JRE作用就是我们写java代码所需要的资源库支持，和运行所需要的虚拟机都在jre中。

JVM是Java Virtual Machine（Java[虚拟机][Link 1]）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。（虚拟机就好像是 模拟器。我们现在电脑上面有很多软件能模拟 安卓操作系统。然后可以在电脑上面下载安卓手机软件玩手机游戏 ，虚拟机和模拟器差不多。我们的java代码需要在虚拟机中才能运行 ）

JDK 中包含 JRE ，JRE中包含 JVM

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA_size_16_color_FFFFFF_t_70 1][]  
所以说我们电脑上要开发java 就需要安装JDK。

\#\#\#第二节、jdk的安装和配置

#### 2.1 安装 ####

在 我们电脑的某个盘符下创建一个文件夹 叫java。这个文件夹专门用来安装JDK所需要的文件（不能有中文路径）

双击JDK

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA_size_16_color_FFFFFF_t_70 2][]  
点击【下一步】

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA_size_16_color_FFFFFF_t_70 3][]  
安装过程中会弹出安装JRE的选项，这是java运行环境，因为JDK中自带JRE，所以可以选择不装。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA_size_16_color_FFFFFF_t_70 5][]在这里插入图片描述

此时 JDK安装完成。我们的电脑上面安装了JDK，但是电脑需要配置环境变量才能识别。（配置环境变量：我们写的java代码需要到jdk中的jvm里运行，但是每个人安装的位置不一样，jvm到底在哪，电脑此时不知道，所以我们需要告诉自己的电脑 ，jdk安装到哪了。此时就是配置环境变量）

#### 2.2 配置环境变量 ####

【我的电脑】-右键-【属性】-【高级系统设置】-【环境变量】

![1556853328378][]

【系统变量】-【新建】-java\_home:jdk安装根目录

![1556853478624][1556853328378]

**【新建】**\-classpath：**.;%java\_home%\\lib**

**【编辑】**\-path：**添加** **%java\_home%\\bin**

![1556853647433][1556853328378]

测试：在命令窗口输入java和javac命令观察结果

![image-20201015113553191][1556853328378]

#### 2.3 java的运行原理 ####

平台： Windows OS MacOS Linux OS

跨平台： 不同的操作系统，内部的运行原理是不一样，换句话说，windows的软件不能在mac电脑上面进行安装。所以我们很多软件的制作成本就加大了。例如 爱奇艺，需要制作windows版 还需要制作mac版。此时就需要两个开发团队。假如你是老板，急需一种操作：能不能开发一个版本在不同的平台中都能运行，这就是跨平台。

Java是支持跨平台操作的一门语言。一次编写 多处运行。

Java跨平台实现的原理：

我们使用java语言开发一套程序。然后编译成字节码文件。在不同的平台中安装该平台对应的jvm，此时 就能运行我们的字节码了。

java virtual machine jvm:虚拟机，利用软件的形式模拟一台虚拟计算机的环境。java跨平台的特性。同样的一份代码可以运行在不同的操作系统上。

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9vdy8hi3-1616211187442)(assets/image-20201016084302932.png)\]

java源文件——【javac 命令编译】——.class文件——【java 命令运行】

#### 2.4 创建第一个java程序 ####

##### 示例1：使用记事本编写HelloWorld #####

在E盘根目录创建Hello.java文件，注意文件后缀是：.java ，而不是：.txt 。

public class HelloWorld { 
        public static void main(String[] args){ 
            System.out.println("你好java");   
        }
    }

【cmd】——打开命令行窗口

输入：【E:】 + 【enter】进入E盘

输入：【javac HelloWorld.java】命令，注意这里要带文件后缀【.java】

如果没有反应，就说明编译完成，此时同目录下会多一个**HelloWorld.class**文件

然后输入：**【java HelloWorld】**

输出：**浣犲ソjava**

这是因为编码格式问题，可以在编译时加入指定的编码集：utf-8

输入【javac -encoding utf-8 Hello.java】

输入：**【java Hello】**

输出：**你好java**

##### 示例2：使用EditPlus编写HelloWorld（可选） #####

【新建】-【java】

class  
    { 
    	public static void main(String[] args) 
    	{ 
    		System.out.println("Hello World!");
    	}
    }

写入类名：Hello

保存为Hello.java文件

配置javac命令行工具：

【tools】-【prefersences】打开工具配置并进行如下配置

![image-20200720104851808][1556853328378] ![image-20200720105049663][1556853328378]

#### 2.5 java注释 ####

很多人毕业了 注释都不会加。---- 很多程序员都加不对

Java的注释分成三种：

单行注释： // 注释部分

多行注释： /\* 注释部分 \*/

文档注释： /\*\* 注释部分 \*/

/** * 这是文档注释 */
    public class Hello { 
        public static void main(String[] args){ 
            System.out.println("你好java");
            /*String form=MessageFormat.format("你好：{0},我是{1}，今年{2}岁了","花和尚","豹子头",23); System.out.println(form); 这是整段注释*/
            //这是单行注释
        }
       /*这是整段注释 public void test(){ System.out.println("这是测试方法"); } */
    }

### 第三节：类的基本概念 ###

#### 3.1 创建包package ####

在java中有包的概念。包的英文名称为 package。包其实就是一个文件夹。也就是说我们创建包就是创建文件夹，在java中我们需要创建的文件要分包管理。

其实就和我们前端一样的思想：css文件夹 里面存放的是css文件，img文件夹存放的是 资源文件。 java的包和这些文件夹有异曲同工之妙。我们java的分包是 创建不同的包 用来存放不同功能的java文件。

##### 操作： #####

1）选中src 【右键】—【new】 —【package】

![image-20201016090843166][1556853328378]

2）输入包名，如果有子包，则使用“.”连接和间隔

![image-20201016091302583][1556853328378]

##### 包名的命名规范： #####

全小写 点分割 反域名 （严格遵循）

例如 ： com.aaa.taobao.test com.alibaba.taobao.util

**com** ： 代表不同的类型 如果是com 代表企业组织 org 代表公益组织 java开头 代表原生代码

**aaa** ： 代表公司名称 如果没有公司 就用自己的名字 com.gfs.taobao.com

**taobao**: 代表项目名称 平时的时候我们都省略

**test** ： 当前包的作用 例如 test 测试代码 util 工具类代码 dao 数据访问层代码

从今天开始我们写任何代码 都要遵循代码的命名规范。

很多人说 我现在在做练习，不用注意规范。还有人说我没有遵循命名规范 这不也没有什么错误吗？

\----- 命名规范是约定俗成。

\#\#\#\#3.2 创建类

【File】——【New】——【Project】

![image-20200623171054221][1556853328378]

选择【java】，一般默认就是你安装的JDK版本【这里是1.8】，然后【Next】

![image-20200623171237494][1556853328378]

直接点击【Next】

![image-20200623171455048][1556853328378]

在项目目录【src】上右键——【New】——【java Class】——输入文件名称【Hello】，注意首字母要大写

public class Hello { 
        
    }

大括号中间添加代码：

public static void main(String[] args){ 
            System.out.println("你好java");       
        }

点击边上的箭头即可运行。

#### 3.3 类的构成 ####

package com.aaa;
    /** * @author: wangxiangnan * @time: 2020/10/16 9:31 * @description: */
    public class HelloWorld { //[修饰符] class关键词 类名{类体，简单理解为写代码的地方，}
    
       /** * public 访问修饰符，公有的，还有其它的private protected等，以后会讲 * static 静态的，以后会讲 * void 代表该方法没有返回值 * args 运行时传入的参数 */
        public static void main(String[] args){ 
            System.out.println("你好java");
        }
       //还可以有其它的方法
       public static void test(){ 
          System.out.println("这是测试方法");
       }
    }

#### 3.4 类文件（Xxxxx.java）中的类 ####

面试题： 请求一个.java中可以有多个类（外部类）吗？有什么要求？

答案：A 可以有多个类

package com.aaa;
    
    public class HelloWorld { 
    
        public static void main(String[] args){ 
            System.out.println("你好java");
        }
    }
    
    class testAClass{ 
    
    }
    class testBClass{ 
    
    }

但一个类文件中只能有一个用**public**修饰的类，并且该类的类名必须和类文件名相同。

#### 3.5 错误信息处理 ####

如果public修饰的类名和文件名不同则会出现错误

![image-20201016095002091][1556853328378]

Class 'HelloWorld1' is public, should be declared in a file named 'HelloWorld1.java'
    
    这个公共类型 HelloWorld1 必须 被  声明 到 一个名为 HelloWorld1 的文件中。

![image-20201016095256292][1556853328378]

鼠标放到错误提示的红线上会在左上角出现一个小红灯泡，点击灯泡旁边的下拉箭头，会出现几个建议改正的选项，可以点击使用其中一个来修改错误，一般使用最后一个“Rename class ‘HelloWorld1’ to ‘HelloWorld’”

#### 3.6 java文件的运行机制 ####

![image-20201016104344704][1556853328378]

\#\#\#第四节：数据类型、变量

\#\#\#\#一、java的数据类型

##### 基本数据类型8种： #####

整形：byte,short,int,long

浮点型:float ,double

字符型:char

布尔型:boolean

引用数据类型：

String “1234” 字符串类型的值必须使用双引号将内容包裹，

如果没有包裹，有两层含义：1）如果是文字字符则可能是变量；2）如果是数字字符则是数字值。

“1234” **!=** 1234

注意： 在java中 单引号代表的是 字符类型 双引号代表的是字符串类型

但是在js中 单引号和双引号都是字符串类型

字符类型只能存储一个字符 字符串可以存储多个。

**面试题**： 请问 String 是基本数据类型吗？

**警告：很多人毕业的时候 八种基本数据类型都忘了。**

<table> 
 <thead> 
  <tr> 
   <th>类型名称</th> 
   <th>关键字</th> 
   <th>占用内存</th> 
   <th>取值范围</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>字节型</td> 
   <td>byte</td> 
   <td>1 字节</td> 
   <td>-128~127</td> 
  </tr> 
  <tr> 
   <td>短整型</td> 
   <td>short</td> 
   <td>2 字节</td> 
   <td>-32768~32767</td> 
  </tr> 
  <tr> 
   <td><strong>整型</strong></td> 
   <td>int</td> 
   <td>4 字节</td> 
   <td>-2147483648~2147483647</td> 
  </tr> 
  <tr> 
   <td>长整型</td> 
   <td>long</td> 
   <td>8 字节</td> 
   <td>-9223372036854775808L~9223372036854775807L</td> 
  </tr> 
  <tr> 
   <td>单精度浮点型</td> 
   <td>float</td> 
   <td>4 字节</td> 
   <td>+/-3.4E+38F（6~7 个有效位）</td> 
  </tr> 
  <tr> 
   <td>双精度浮点型</td> 
   <td>double</td> 
   <td>8 字节</td> 
   <td>+/-1.8E+308 (15 个有效位）</td> 
  </tr> 
  <tr> 
   <td>字符型</td> 
   <td>char</td> 
   <td>2 字节</td> 
   <td>ISO 单一字符集</td> 
  </tr> 
  <tr> 
   <td>布尔型</td> 
   <td>boolean</td> 
   <td>1 字节</td> 
   <td>true 或 false</td> 
  </tr> 
 </tbody> 
</table>

1GB(一部电影) = 1024 MB 1MB(一张照片) = 1024KB

1KB(一个文档) = 1024B 1B就是一个字节 1B = 8b

一个字节在内存中就是8位二进制数

所以我们电脑的运行内存8G,当我们写的java程序中 有一句 **int a = 10;** 相当于在你的电脑运行内存的8G中 有四个字节的内存被这个a所占据

Java希望我们在编程的时候 能选择合适的数据类型，从而控制内存。例如 我们要存储一个人的年龄，人普遍年龄是 0-125.所以可以选择使用 byte类型，那么此时我们如果使用 int 类型 也可以，但是浪费内存。如果要存储一个乌龟的年龄，可以使用short类型。这就是为什么java能存储整数 需要四种类型。

### 第五节：标识符和运算符 ###

#### 一、java的标识符 ####

以下划线，$或字母开头，不能有特殊字符，中间不能有空格，关键字不能用，大小写严格区分。

#### 二、变量声明和使用 ####

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

比较运算符(下一章再讲)

`> , >= , < , <= , == , !=`

逻辑运算符(下一章再讲)

&&，||，！

##### 为什么我们写完代码会报黄色警告？ #####

在java中 波浪线的是 警告 ，代码没有问题，可以运行，但是不完美，有瑕疵，一般是该变量没有被后续代码所使用。

红色的是 错误，代码有问题，无法运行。

![image-20201016114003300][1556853328378]

面试题： 请问java中的char类型能否存储一个汉字 ？问什么？

答案：java中的char类型可以存储一个汉字，因为一个汉字所占的内存是2字节，java中的char类型能存储的大小也是两个字节。所以能存储汉字。

一个字母占一个字节。很多人就有疑问，char能存储两个字节，那不就是能存储两个字母吗？注意 char类型只能存储一个字母。

可以这样理解。有一辆车 最多坐一个人并且载重360斤。也就是说即使一个人中80斤 那个也不可能上4个这样的人。

#### 四、数据类型转换 ####

##### 自动类型转换 #####

在java中遵循类型匹配原则，但是会出现这种情况：

short a=9;
    int b=a;

此时a的类型是short类型 b的类型是 int类型，a和b的数据类型不匹配，此时也能完成赋值，而且不报错，为什么呢？

因为此处发生了自动类型转换

![image-20201016135122677][1556853328378]

也就是说 ，在java中 数据类型占据字节内存小的 给 占据字节内存大的赋值 是没有问题的。就好像将一个小杯子里面的内容给大杯子 是不会出问题的。

##### 强制类型转换 #####

在java中有的时候 我们需要将 所占内存大的类型 赋值给 所占内存小的类型。此时就会报错：

int a=90;
    short b=a;
    //Incompatible types. 不兼容的类型
    //Required:short Found: int 要求short 却发现int

将 int类型的变量a 赋值给 short类型的变量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 + 类名（参数列表）\{初始化代码\}
 *  当类没有构造方法时，系统会给一个默认的空构造方法
 *  当你一旦定义了自己的构造方法，系统就收回了默认的构造方法
 *  如果还想用默认的构造方法，则必须自己另外定义
 *  自定义的构造方法主要用于对象的初始化

### 第四节：定义一般方法 ###

语法： 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();
    	}

![1560650353209][1556853328378]

示例：售票员

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日）,并计算这个人的年龄。

## 第五章：数组操作 ##

#### 回顾： ####

*  String和StringBuilder和StringBuffer的区别
 *  学过的String的方法
 *  以下代码是能输出什么格式的日期字符串：

SimpleDateFormat sdf=new SimpleDateFormat();
    Date date=new Date();
    System.out.println(sdf.format(date);

#### 本章内容： ####

*  数组的定义
 *  数组的访问
 *  数组的排序
 *  二维数组
 *  Arrays的使用

### 第一节：数组的定义和访问 ###

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

### 第二节：数组的排序（重点） ###

冒泡排序：

![bubble][1556853328378]

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

#### 选择排序： ####

![selectionSort][1556853328378]

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：借出

## 第六章：共享汽车出租管理系统 ##

![image-20200722111612631][1556853328378]

### 第一节：创建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<CarManager.carCount;i++){
                if(db[i].getCarno().equals(carNo)){
                    return i;
                }
            }
            return -1;
        }
    
        public void searchCar(){//用于按照名字和车牌号的模糊查询
            System.out.println("请输入要查找的车辆信息");
            String nameOrNo=sc.next();
            for(int i=0;i<CarManager.carCount;i++){
                if(db[i].getCarno().contains(nameOrNo)
                			||db[i].getCarname().contains(nameOrNo)){
                    System.out.println(db[i]);
                }
            }
        }
        public void showCar() {//循环输出所有车辆信息
        	System.out.println("展示汽车");
            for(int i=0;i<CarManager.carCount;i++){
                System.out.println(db[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<CarManager.carCount;i++){
                        db[i]=db[i+1];
                    }
                    CarManager.carCount--;
                    System.out.println("汽车"+carno+"报废完毕");
                }
            }
        }

第十节：实现营收统计和排行

public void showAccount() {//加和所有的车辆营收金额
            double sum=0;
            for(int i=0;i<CarManager.carCount;i++){
                sum+=db[i].account;
            }
            System.out.println("总营收为："+sum);
        }
    
        public void sortAccount(){//使用冒泡排序法对车辆营收从高到低排列
             Car temp;
             for(int j=1;j<CarManager.carCount;j++){
                for(int i=0;i<CarManager.carCount-j;i++){
                    if(db[i].account<db[i+1].account){
                        temp=db[i];
                        db[i]=db[i+1];
                        db[i+1]=temp;
                    }
                }
             }
    
             for(int i=0;i<CarManager.carCount;i++){
                 System.out.println(db[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<CarManager.carCount;i++){
                    db[i]=db[i+1];
                }
                CarManager.carCount--;
                System.out.println("汽车"+carno+"报废完毕");
            }
        }
    }

第十节：实现营收统计和排行

public void showAccount() \{//加和所有的车辆营收金额  
double sum=0;  
for(int i=0;i<CarManager.carCount;i++)\{  
sum+=db\[i\].account;  
\}  
System.out.println(“总营收为：”+sum);  
\}

public void sortAccount(){//使用冒泡排序法对车辆营收从高到低排列
         Car temp;
         for(int j=1;j<CarManager.carCount;j++){
            for(int i=0;i<CarManager.carCount-j;i++){
                if(db[i].account<db[i+1].account){
                    temp=db[i];
                    db[i]=db[i+1];
                    db[i+1]=temp;
                }
            }
         }
    
         for(int i=0;i<CarManager.carCount;i++){
             System.out.println(db[i]);
         }
    }

[-]: /images/20221022/f836ce774df64ab284adc2c9fa9c8752.png
[- 1]: https://img-blog.csdnimg.cn/20210320113507999.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA==,size_16,color_FFFFFF,t_70
[- 2]: https://img-blog.csdnimg.cn/20210320113528263.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA==,size_16,color_FFFFFF,t_70
[img]: http://www.gf521.com/pic/13170204-14509.jpg
[- 3]: https://img-blog.csdnimg.cn/20210320113551964.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA==,size_16,color_FFFFFF,t_70
[- 4]: https://img-blog.csdnimg.cn/20210320113619256.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA==,size_16,color_FFFFFF,t_70
[- 5]: https://img-blog.csdnimg.cn/20210320113640428.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210320113707650.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA==,size_16,color_FFFFFF,t_70
[Link 1]: https://baike.baidu.com/item/%E8%99%9A%E6%8B%9F%E6%9C%BA
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210320113749563.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210320113835566.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210320113851319.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210320113906813.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20210320113918870.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hlbjEyNA==,size_16,color_FFFFFF,t_70
[1556853328378]: