📝老杜javase进阶笔记（一）

day19天

idea开发工具

1. 安装
   • 不要安装汉化版本，英语单词多记清楚位置。
2. IDEA的使用步骤：
   • 在空的工程下新建Module（模块），IDEA中模块类似于eclipse当中的project。
     eclipse的组织方式：workspace—> project

idea的组织方式：project —> module

IDEA工具的一些设置

1. 包 的显示方式的设置
   
2. 怎么创建module?
   file菜单—>new —> Module
   创建同级别 moudel 的方式
   注意：在你需要保存的位置创建好目录—>然后file菜单—>new —> Module—>在对应按钮选择你要保存的目录
   或者
   在弹出的窗口自己选择路径，手动输入文件夹名称，finsh就行

• 在New Module窗口上点击左上角的java，然后next
• 给module起一个名字：chapter15
• 编写代码，在src目录下新建类，写代码，并运行。

1. 怎么调节字体大小
   字体设置：file —> settings —> 输入font —> 设置字体样式以及字号大小

2. 黑色背景设置
   file —> settings —> Appearance&Behavior—> Appearance—> Theme—>Darcula

3. 如何用idea看到自己以前写的project

   • 

• 这样子选择好自己想要切换的project，点击确定。然后，选择This Windows按钮就可以查看到自己以前写的project啦！

1. 怎么修改文件名称
   操作如下： 快捷键：shift + F6
   
2. 怎么给程序传递参数：
   第一步：
   
   第二步:
   
3. 删除文件的时候将勾去掉

1. idea中

idea开发的快捷键

• 快速生成main方法： 快捷键：psvm
• 快速生成：System.out.println() 快捷键：sout
• 注意：IDEA是自动保存，不需要ctrl + s
• 删除一行 快捷键：ctrl + y

• 怎么运行：
  代码上右键—>run
  或者点击左侧的绿色箭头。
  ctrl + shift + F10

• 左侧窗口中的列表怎么展开？怎么关闭？
  左箭头关闭。
  右箭头展开。
  上下箭头移动。

• idea中退出任何窗口，都可以使用esc键盘。（esc就是退出）

• 任何新增/新建/添加的快捷键是：
  alt + insert

• 窗口变大，变小：
  ctrl + shift + F12
• 切换java程序：从HelloWorld切换到User
  alt + 右箭头 或者 alt + 左箭头
• 切换窗口：
  alt + 标号
  alt + 1（打开，关闭）
  alt + 2
• 提示方法的参数： ctrl + p

• 注释：
  单行注释：ctrl + /
  多行注释：ctrl + shift + /

• idea中怎么定位方法/属性/变量？
  光标停到某个单词的下面，这个单词可能是：方法名、变量名、一个类。停到单词下面之后，按ctrl键，出现下划线，鼠标点击跳转。

• idea当中复制一行是：ctrl + d

• 如果有红线报错 纠错的方式
  光标移动到红色下划线上面，按住快捷键 alt + 回车

• 类实现接口
  快捷生成接口中的抽象方法快捷键： alt + 回车 + 选中的抽象方法 + 回车

• IDEA中生成tostring与equals方法： alt+insert 搜索 tostring 或者 equals

• shift 敲两次 出现搜索框 搜索类

• 查看类的方法 ctrl+F12

• 快捷生成方法的方式： 找到未写然后报红的方法，鼠标点击， alt + 回车

• shift+F6 选中要改名的文件，快捷修改名称

• 编辑多行 按住alt 向下拖就行了

• 快捷键 输入 ifn 回车 （未设置）

这是在Io流那里的快捷键 finally 语句中快速生成 if（？？？ == null）的

day20 学习方法记住结论，自己写程序去测试加深理解

final 关键字

final关键字

复习：局部变量没有初始值，需要程序员手动赋值，成员变量有默认值。

1. final修饰的类无法继承。
2. final修饰的方法无法覆盖。
3. final修饰的变量只能赋一次值。
4. final修饰的引用一旦指向某个对象，则不能再重新指向其它对象，该引用指向对象内部的数据是可以修改的。
   内存图理解：
   
5. final修饰的实例变量必须手动初始化，不能采用系统默认值。（赶在系统赋默认值之前修改也是可以的）

常量

1. final修饰的实例变量一般和static联合使用，称为常量。常量在方法区中
   public static final double PI = 3.1415926;
   总结：final表示最终的，不可修改的。

抽象类与接口

抽象类

抽象类的理解：

![](https://gitee.com/hei-yubai/javase/raw/master/img/202203031243073.png#crop=0&crop=0&crop=1&crop=1&id=SMRa5&originHeight=549&originWidth=1359&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)

1. 抽象类怎么定义？
   在class前添加abstract关键字就行了。

2. 抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的。

3. final和abstract不能联合使用，这两个关键字是对立的。
4. 抽象类的子类可以是抽象类。也可以是非抽象类。
5. 抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的。
6. 抽象类中不一定有抽象方法，抽象方法必须出现在抽象类中，且方法不能有方法体。
7. 抽象方法怎么定义？
   public abstract void doSome(); 不能有大括号{}
8. • （重点）一个非抽象的类，继承抽象类，必须将抽象类中的抽象方法进行覆盖/重写/实现。
   • 到目前为止，只是学习了抽象类的基础语法，一个类到底声明为抽象还是非抽象，这个以后慢慢来吧。写代码多的时候，自然就理解了。

9. 面试题（判断题）：java语言中凡是没有方法体的方法都是抽象方法。

   • 不对，错误的
   • Object类中就有很多方法都没有方法体，都是以“;”结尾的，但他们都不是抽象方法，例如：
     public native int hashCode();
     这个方法底层调用了C++写的动态链接库程序。
     前面修饰符列表中没有：abstract。有一个native，表示调用JVM本地程序。

接口

implements

• 接口的基础语法：
  1. 接口是一种“引用数据类型”
  2. 接口是完全抽象的。
  3. 接口怎么定义：[修饰符列表] interface 接口名{}
  4. 接口支持多继承。
  5. 接口中只有常量+抽象方法。（注意看jdk的版本，若为jdk8版本的话这句话不适用，接口中还有其它方法。）
  6. 接口中所有的元素都是public修饰的
  7. 接口中抽象方法的public abstract可以省略。
  8. 接口中常量的public static final可以省略。
  9. 接口中方法不能有方法体。

day21天 （笔记只体现核心的东西即可，方便以后复习）

• 接口在开发中的作用
  • 重点：解耦合

• 面向接口编程，可以降低程序的耦合度，提高程序的扩展力，符合OCP开发原则。

  • 接口的使用离不开多态机制。（接口+多态才可以达到降低耦合度。）

• 接口可以解耦合，解开的是谁和谁的耦合！！！

  - 任何一个接口都有调用者和实现者。
  - **接口可以将调用者和实现者解耦合。**
  - **调用者面向接口调用。**
  - **实现者面向接口编写实现。**

• 以后进行大项目的开发，一般都是将项目分离成一个模块一个模块的，模块和模块之间采用接口衔接，降低耦合度。

1. 注意：接口在开发中的作用，类似于多态在开发中的作用。
   多态：面向抽象编程，不要面向具体编程，降低程序的耦合度，提高程序的扩展力。

       /*
           public class Master{
               public void feed(Dog d){}
               public void feed(Cat c){}
               //假设又要养其它的宠物，那么这个时候需要再加1个方法。（需要修改代码了）
               //这样扩展力太差了，违背了OCP原则（对扩展开放，对修改关闭。）
           }
           */
       public class Master{
           public void feed(Animal a){
               // 面向Animal父类编程，父类是比子类更抽象的。
               //所以我们叫做面向抽象编程，不要面向具体编程。
               //这样程序的扩展力就强。
           }
   }

2. 接口在开发中的作用？

• 接口是不是完全的？ 是
• 而我们以后正好要求，面向抽象编程。
• 面向抽象编程这句话以后可以修改为：面向接口编程。
• 有了接口就有了可插拔。可插拔表示扩展力很强。不是焊接死的。
• 主板和内存条之间有插槽，这个插槽就是接口，内存条坏了，可以重新买一个换下来。这叫做高扩展性。（低耦合度。）
  1. 接口在现实世界中是不是到处都是呢？
     螺栓和螺母之间有接口
     灯泡和灯口之间有接口
     笔记本电脑和键盘之间有接口（usb接口，usb接口是不是某个计算机协会制定的协议/规范。）
     接口有什么用？扩展性好。可插拔。
     接口是一个抽象的概念。

类型与类型之间的关系

**is a（继承）、has a（关联）、like a（实现）**implemen

is a（是一个）：
Cat is a Animal（猫是一个动物）
凡是能够满足is a的表示“继承关系”
A extends B

has a（有一个）：
I has a Pen（我有一支笔）
凡是能够满足has a关系的表示“关联关系”
关联关系通常以“属性”的形式存在。
A{
B b;
}

like a（像一个）:
Cooker like a FoodMenu（厨师像一个菜单一样）
凡是能够满足like a关系的表示“实现关系”
实现关系通常是：类实现接口。
A implements B

抽象类和接口有什么区别？

    在这里我们只说一下抽象类和接口在语法上的区别。<br />        至于以后抽象类和接口应该怎么进行选择，通过后面的项目去体会/学习。

• 抽象类是半抽象的。
  接口是完全抽象的。
• 抽象类中有构造方法。
  接口中没有构造方法。
• 接口和接口之间支持多继承。
  类和类之间只能单继承。
• 一个类可以同时实现多个接口。
  一个抽象类只能继承一个类（单继承）。
• 接口中只允许出现常量和抽象方法。（应该jdk的版本，jdk1.8版本不适用）
• 这里先透露一个信息：
  • 以后接口使用的比抽象类多。一般抽象类使用的还是少。
  • 接口一般都是对“行为”的抽象。

chapter17

package和import

package

1. 注意事项：

• 第一：package出现在java源文件第一行。
• 第二：带有包名怎么编译？ javac -d . xxx.java
• 第三：怎么运行？ java 完整类名
  补充：以后说类名的时候，如果带着包名描述，表示完整类名。如果没有带包，描述的话，表示简类名。
  java.util.Scanner 完整类名
  Scanner 简类名

1. package语法：

• package 公司域名.项目名称.模块名.功能名称 ;

import

1. import 什么时候不需要？
   java.lang不需要。
   同包下不需要。
   其它一律都需要。
2. 怎么用？
   • import 完整类名;
   • import 包名.; 只能到类名那一级，只能指定某个类的类名
     import java.util.Scanner; // java.util.Scanner 完整类名。
     Scanner 是 类名 java.util 是 包名
3. 同学的疑问：包名.* 这样是不是效率比较低。
   • 这个效率不低，因为编译器在编译的时候，会自动把 变成具体的类名，import java.util.类名;

day 22天

访问控制权限

访问控制权限

5.1 访问控制权限都有哪些？ 4个。
private 私有

    public     公开
    protected    受保护
    默认

5.2 以上的4个访问控制权限：控制的范围是什么？ 可以看下面的表格
private 表示私有的，只能在本类中访问

    **public 表示公开的，在任何位置都可以访问**
    **“默认”表示只能在本类，以及同包下访问。**
    **protected表示只能在本类、同包、子类中访问。**

访问控制修饰符

范围从大到小排序：public > protected > 默认 > private

5.3 访问控制权限修饰符可以修饰什么？
属性（4个都能用）

    方法（4个都能用）
    类（public和默认能用，其它不行。）
    接口（public和默认能用，其它不行。）

chapter18

object 类

1. JDK类库的根类

   • 这个老祖宗类中的方法我们需要先研究一下，因为这些方法都是所有子类通用的。任何一个类默认继承Object。就算没有直接继承，最终也会间接继承。

2. 目前为止我们只需要知道这几个方法即可：

• protected Object clone() // 负责对象克隆的。
• int hashCode() // 获取对象哈希值的一个方法。
• boolean equals(Object obj) // 判断两个对象里的内容是否相等
• String toString() // 将对象转换成字符串形式
• protected void finalize() // 垃圾回收器负责调用的方法

API

1. 什么是API

• 应用程序编程接口。（Application Program Interface）
• 整个JDK的类库就是一个 javase 的 API 。
• 每一个API都会配置一套API帮助文档。
• SUN公司提前写好的这套类库就是API。（一般每一份API都对应一份API帮助文档。）

tostring()方法

1. 以后所有类的toString()方法是需要重写的。

• 重写规则，越简单越明了就好。
• System.out.println(引用); 这里会自动调用 “引用” 的toString()方法。
• String类是SUN写的，toString方法已经重写了。

1. 源代码长什么样？

   • 源代码如下：

     public String toString() {
      return this.getClass().getName() + "@" + Integer.toHexString(hashCode());
     }

   • 源代码上toString()方法的默认实现是：类名@对象的内存地址转换为十六进制的形式

   • SUN公司设计toString()方法的目的是什么？
     • toString()方法的设计目的是：通过调用这个方法可以将一个“java对象”转换成“字符串表示形式”
     • 其实SUN公司开发java语言的时候，建议所有的子类都去重写toString()方法。
       toString()方法应该是一个简洁的、详实的、易阅读的.
2. 写一个源代码重写tostring（）的方法

equals（object obj）方法

1. 以后所有类的equals方法也需要重写，因为Object中的equals方法比较的是两个对象的内存地址，我们应该比较内容，所以需要重写。

2. 默认的equals方法的源代码如下：

   public boolean equals(Object obj) {
               return (this == obj);
           }

3. SUN公司设计equals方法的目的是什么？

   • 以后编程的过程当中，都要通过equals方法来判断两个对象是否相等。
   • equals方法是判断两个对象是否相等的。
4. Object类给的这个默认的equals方法够不够用？
   • 在Object类中的equals方法当中，默认采用的是“ == ”判断两个java对象内存地址是否相等。
   • 而“ == ”判断的是两个java对象的内存地址，我们应该判断两个java对象的内容是否相等。所以老祖宗的equals方法不够用，需要子类重写equals。
   • 判断两个java对象是否相等，不能使用“ == ”，因为“ == ”比较的是两个对象的内存地址。
5. 重写Object类的equals方法：
   怎么重写？
   复制 粘贴 相同的返回值类型、相同的方法名、相同的形式参数列表。

• 重写规则：自己定，主要看是什么和什么相等时表示两个对象相等。
• 基本数据类型比较时用： ==
• 对象和对象比较：调用 equals 方法
• String类是SUN编写的，所以String类的equals方法重写了。
• 以后判断两个字符串是否相等，最好不要使用==，要调用字符串对象的equals方法。
  注意：重写equals方法的时候要彻底。

1. IDEA中生成tostring与equals方法： alt+insert 搜索 tostring 或者 equals
2. equals（object o）方法重新格式如下：
   ```java public boolean equals(Object obj) {

   // 如果obj是空，直接返回false
   // 如果obj不是一个MyTime，没必要比较了 ，直接返回false
   if(obj == null || !(obj instanceof MyTime)){
       return false;
   }
    // 如果this和obj保存的内存地址相同，没必要比较了，直接返回true。
   // 内存地址相同的时候指向的堆内存的对象肯定是同一个。
   if(this == obj){
       return true;
   }
   // 程序能够执行到此处说明什么？
   // 说明obj不是null，obj是MyTime类型。
   MyTime t = (MyTime)obj;
   return this.year == t.year && this.month == t.month && this.day == t.day ;

   }

}

   -  当方法体中只有一行代码时，大括号可以省略 
   -  用IDEA开发不需要写，可以快捷生成。 
<a name="R0fnK"></a>
## String 类
1.  String类已经重写了equals方法，比较两个字符串不能使用==，必须使用equals。equals是通用的。 
2.  **String类已经重写了toString方法。** 
3.  总结： 
   -  **java中基本数据类型比较是否相等，使用 ==** 
   -  **java中所有的引用数据类型，统一使用equals方法来判断是否相等。**<br />以上是规矩 
4.  测试 string 类中的 equals、tostring方法有没有重写 
```java
public class Test03{
    public static void main(String[] args){
        // 大部分情况下，采用这样的方式创建字符串对象
        String s1 = "hello";
        String s2 = "abc";
        // 实际上String也是一个类。不属于基本数据类型。
        // 既然String是一个类，那么一定存在构造方法。
        String s3 = new String("Test1");
        String s4 = new String("Test1");
        // new两次，两个对象内存地址，s3保存的内存地址和s4保存的内存地址不同。
        // == 判断的是内存地址。不是内容。
        System.out.println(s3 == s4); // false
        // 比较两个字符串能不能使用双等号？
        // 不能，必须调用equals方法。
        // String类已经重写equals方法了。
        System.out.println(s3.equals(s4)); // true
        // String类有没有重写toString方法呢？
        String x = new String("动力节点");
        // 如果String没有重写toString()方法，输出结果：java.lang.String@十六进制的地址
        // 经过测试：String类已经重写了toString()方法。
        System.out.println(x.toString()); //动力节点
        System.out.println(x); //动力节点
    }
}

equals 的深层理解

1. 重写equals方法要彻底的例子：（看懂原理，自己能够写出来）

public class Test05{
    public static void main(String[] args){
        // 多态（自动类型转换。）
        Object o1 = new String("hello world!");
        Object o2 = new User();
        Object o3 = new Address();
        User u1 = new User("zhangsan", new Address("北京","大兴区","11111"));
        User u2 = new User("zhangsan", new Address("北京","大兴区","11111"));
        System.out.println(u1.equals(u2)); // true
        User u3 = new User("zhangsan", new Address("北京","朝阳区","11112"));
        System.out.println(u1.equals(u3)); // false
    }
}
class User{
    // 用户名
    String name; 
    // 用户的住址
    Address addr;
    public User(){
    }
    public User(String name, Address addr){
        this.name = name;
        this.addr = addr;
    }
    // 重写equals方法
    // 重写规则：当一个用户的用户名和家庭住址都相同，表示同一个用户。
    // 这个equals判断的是User对象和User对象是否相等。
    public boolean equals(Object obj){
        // 用户名和用户名相同，住址和住址相同的时候，认定是同一个用户。
        if(obj == null || !(obj instanceof User)) return false;
        if(this == obj) return true;
        User u = (User)obj;
        if(this.name.equals(u.name) && this.addr.equals(u.addr)){
            return true;
        }
        return false;
    }
}
class Address{
    String city;
    String street;
    String zipcode;
    public Address(){
    }
    public Address(String city,String street,String zipcode){
        this.city = city;
        this.street = street;
        this.zipcode = zipcode;
    }
    // 注意：这里并没有重写equals方法。
    // 这里的equals方法判断的是：Address对象和Address对象是否相等。
    public boolean equals(Object obj){
        if(obj == null || !(obj instanceof Address)) return false;
        if(this == obj) return true;
        // 怎么算是家庭住址相同呢？
        // 城市相同，街道相同，邮编相同，表示相同。
        Address a = (Address)obj;
        if(this.city.equals(a.city) 
            && this.street.equals(a.street) 
            && this.zipcode.equals(a.zipcode)){
            return true;
        }
        return false;
    }
}

finalize()方法 （了解内容）

1. JDK 9 版本开始方法过时，了解即可

2. 在Object类中的源代码：

   protected void finalize() throws Throwable { }

3. GC： 负责调用finalize()方法

4. finalize()方法只有一个方法体，里面没有代码，而且这个方法是protected修饰的。
5. 这个方法不需要程序员手动调用，JVM的垃圾回收器负责调用这个方法。不像equals toString，equals和toString()方法是需要你写代码调用的。
6. finalize()方法的执行时机：当一个java对象即将被垃圾回收器回收的时候，垃圾回收器负责调用finalize()方法。
7. finalize()方法实际上是SUN公司为java程序员准备的一个时机，垃圾销毁时机。
   如果希望在对象销毁时机执行一段代码的话，这段代码要写到finalize()方法当中。
   
8. 提示：
   java中的垃圾回收器不是轻易启动的，垃圾太少，或者时间没到，种种条件下，有可能启动，也有可能不启动。

9. 建议启动的方法：

           // 有一段代码可以建议垃圾回收器启动。
           if(i % 2 == 0){
               System.gc(); // 建议启动垃圾回收器。（只是建议，可能不启动，也可能启动。                启动的概率高了一些。）
           }
       }

10. 项目开发中有这样的业务需求：所有对象在JVM中被释放的时候，请记录一下释放时间！！！
    静态代码块 可以记录类加载时机

hashcode(方法)【了解】

1. 在Object中的hashCode方法是怎样的？

   public native int hashCode();

   • 这个方法不是抽象方法，带有native关键字，底层调用C++程序。
   • hashCode()方法返回的是哈希码：实际上就是一个java对象的内存地址，经过哈希算法，得出的一个值。
     所以 hashCode() 方法的执行结果可以等同看做一个java对象的内存地址。

2. 测试 hashcode（） 方法的案例：
   ```java public class Test07{ public static void main(String[] args){

   Object o = new Object();
   int hashCodeValue = o.hashCode();
   // 对象内存地址经过哈希算法转换的一个数字。可以等同看做内存地址。
   System.out.println(hashCodeValue); //798154996
   MyClass mc = new MyClass();
   int hashCodeValue2 = mc.hashCode();
   System.out.println(hashCodeValue2); //1392838282
   MyClass mc2 = new MyClass();
   System.out.println(mc2.hashCode()); // 523429237

   } }

class MyClass { }

<a name="94e0e403"></a>
## 内部类
注意：能看懂别人写的程序即可，**尽量不要使用匿名内部类进行开发，使用类实现接口的方式进行开发**
<a name="d0f3b5d7"></a>
### 1. 内部类
1.  什么是内部类？<br />**内部类：在类的内部又定义了一个新的类。被称为内部类。** 
2.  内部类的分类：<br />**静态内部类：类似于静态变量**<br />**实例内部类：类似于实例变量**<br />**局部内部类：类似于局部变量** 
3.  使用内部类编写的代码，可读性很差。能不用尽量不用。 
4.  **匿名内部类是局部内部类的一种。因为这个类没有名字而得名，叫做匿名内部类。** 
5.  学习匿名内部类主要是让大家以后在阅读别人代码的时候，能够理解。并不代表以后都要这样写。 
6.  匿名内部类有两个缺点：<br />缺点1：太复杂，太乱，可读性差。<br />缺点2：类没有名字，以后想重复使用，不能用。  
<a name="51062481"></a>
### 匿名内部类
7.  写个案例来验证匿名内部类 
- 案例如下：
```java
class Test01{
    // 静态变量
    static String country;
    // 该类在类的内部，所以称为内部类
    // 由于前面有static，所以称为“静态内部类”
    static class Inner1{
    }
    // 实例变量
    int age;
    // 该类在类的内部，所以称为内部类
    // 没有static叫做实例内部类。
    class Inner2{
    }
    // 方法
    public void doSome(){
        // 局部变量
        int i = 100;
        // 该类在类的内部，所以称为内部类
        // 局部内部类。
        class Inner3{
        }
    }
    public void doOther(){
        // doSome()方法中的局部内部类Inner3，在doOther()中不能用。
    }
    // main方法，入口
    public static void main(String[] args){
        // 调用MyMath中的mySum方法。
        MyMath mm = new MyMath();
        /*
        Compute c = new ComputeImpl();
        mm.mySum(c, 100, 200);
        */
        //合并（这样写代码，表示这个类名是有的。类名是：ComputeImpl）
        //mm.mySum(new ComputeImpl(), 100, 200);
        // 使用匿名内部类，表示这个ComputeImpl这个类没名字了。
        // 这里表面看上去好像是接口可以直接new了，实际上并不是接口可以new了。
        // 后面的{} 代表了对接口的实现。
        // 不建议使用匿名内部类，为什么？
        // 因为一个类没有名字，没有办法重复使用。另外代码太乱，可读性太差。
        mm.mySum(new Compute(){
            public int sum(int a, int b){
                return a + b;
            }
        }, 200, 300);
    }
}
// 负责计算的接口
interface Compute{ 
    // 抽象方法
    int sum(int a, int b);
}
// 你自动会在这里编写一个Compute接口的实现类
/*
class ComputeImpl implements Compute{
    // 对方法的实现
    public int sum(int a, int b){
        return a + b;
    }
}
*/
// 数学类
class MyMath{
    // 数学求和方法
    public void mySum(Compute c, int x, int y){
        int retValue = c.sum(x, y);
        System.out.println(x + "+" + y + "=" + retValue);
    }    
}

chapter 19 数组

day23

养成良好的开发方式，moudle完了创建包，用 alt+insert 快捷键 输入 package 创建包

数组

数组

1. 什么是数组？ (数组实际上是一种简单的数据结构。)
   • Java语言中的数组是一种引用数据类型，不属于基本数据类型，数组的父类是Object
   • 数组实际上是一个容器，可以同时容纳多个元素。（数组是一个数据的集合。）
   • 数组当中可以存储“基本数据类型”的数据，也可以存储“引用数据类型”的数据。
   • 数组是存储在堆内存当中的
   • 数组当中如果存储的是“java对象”的话，实际上存储的是对象的“引用（内存地址）”，数组中不能直接存储java对象
   • 数组一旦创建，在java中规定，长度不可变
   • 数组的分类：一维数组、二维数组、多维数组…（一维数组较多，二维数组偶尔使用！）
   • 所有的数组对象都有length属性(java自带的)，用来获取数组中元素的个数
   • java中的数组要求数组中元素的类型统一，比如：int类型数组只能存储int类型，Person类型数组只能存储Person类型。
   • 数组在内存方面存储的时候，内存地址连续，这是数组存储元素的特点。
   • 所有的数组都是拿“第一个小方框的内存地址”作为整个数组对象的内存地址。（数组中首元素的内存地址作为整个数组对象的内存地址。）
   • 数组中每一个元素都是有下标的，下标从0开始，以1递增。最后一个元素的下标是：length - 1
2. 数组这种数据结构的优点和缺点是什么？

• 优点：
• 第一：每一个元素的内存地址在空间存储上是连续的。
• 第二：每一个元素类型相同，所以占用空间大小一样。
• 第三：知道第一个元素内存地址，知道每一个元素占用空间的大小，又知道下标，所以通过一个数学表达式就可以计算出某个下标上元素的内存地址。直接通过内存地址定位元素，所以数组的检索效率是最高的。

eg：数组中存储100个元素，或者存储100万个元素，在元素查询/检索方面，效率是相同的，因为数组中元素查找的时候不会一个一个找，是通过数学表达式计算出来的。（算出一个内存地址，直接定位的。）

• 缺点：

• 第一：由于为了保证数组中每个元素的内存地址连续，所以在数组上随机删除或者增加元素的时候，效率较低，因为随机增删元素会涉及到后面元素统一向前或者向后位移的操作。

• 第二：数组不能存储大数据量，为什么？
  因为很难在内存空间上找到一块特别大的连续的内存空间。

• 注意：对于数组中最后一个元素的增删，是没有效率影响的。

1. 数组在堆内存的内存图：
   

一维数组（一）

1. 怎么声明/定义一个一维数组？
   • 语法格式：
     int[] array1;
     double[] array2;
     boolean[] array3;
     String[] array4;
     Object[] array5;
2. 怎么初始化一个一维数组呢？
   • 包括两种方式：静态初始化一维数组，动态初始化一维数组。
   • 静态初始化语法格式：
     int[] array = {100, 2100, 300, 55};
   • 通过下标对数组中的元素进行存和取， array[0] 就应该为 100 ；

• 动态初始化语法格式：
  int[] array = new int[5];
  这里的5表示数组的元素个数，初始化一个5个长度的int类型数组，每个元素默认值0
  String[] names = new String[6];
  初始化6个长度的String类型数组，每个元素默认值null。

1. eg [ 看懂这个列子 并自己敲出来 ] [ 一维数组的遍历 ] :

public class ArrayTest01 {
    public static void main(String[] args) {
        // 声明一个int类型的数组，使用静态初始化的方式
        int[] a = {1, 100, 10, 20, 55, 689};
        // 这是C++风格，不建议java中使用。
        //int a[] = {1, 100, 10, 20, 55, 689};
        // 所有的数组对象都有length属性
        System.out.println("数组中元素的个数" + a.length);
        // 数组中每一个元素都有下标
        // 通过下标对数组中的元素进行存和取。
        // 取（读）
        System.out.println("第一个元素 = " + a[0]);
        System.out.println("最后一个元素 = " + a[5]);
        System.out.println("最后一个元素 = " + a[a.length - 1]);
        // 存（改）
        // 把第一个元素修改为111
        a[0] = 111;
        // 把最后一个元素修改为0
        a[a.length - 1] = 0;
        System.out.println("第一个元素 = " + a[0]);
        System.out.println("最后一个元素 = " + a[5]);
        // 一维数组怎么遍历呢？
        for(int i = 0; i < a.length; i++){
            System.out.println(a[i]); // i是从0到5，是下标
        }
        // 下标为6表示第7个元素，第7个元素没有，下标越界了。会出现什么异常呢？
        //System.out.println(a[6]); //ArrayIndexOutOfBoundsException（比较著名的异常。）
        // 从最后一个元素遍历到第1个元素
        for (int i = a.length - 1; i >= 0; i--) {
            System.out.println("颠倒顺序输出-->" + a[i]);
        }
    }
}

1. 什么时候采用静态初始化方式，什么时候使用动态初始化方式呢？

   • 当你创建数组的时候，确定数组中存储哪些具体的元素时，采用静态初始化方式。
   • 当你创建数组的时候，不确定将来数组中存储哪些数据，你可以采用动态初始化的方式，预先分配内存空间。

   • 案例如下：

     public class ArrayTest02 {
     public static void main(String[] args) {
      // 声明/定义一个数组，采用动态初始化的方式创建
      int[] a = new int[4]; // 创建长度为4的int数组，数组中每个元素的默认值是0
      // 遍历数组
      for (int i = 0; i < a.length; i++) {
          System.out.println("数组中下标为" + i + "的元素是：" + a[i]);
      }
      // 后期赋值
      a[0] = 1;
      a[1] = 100;
      a[2] = 111;
      a[3] = 222; // 注意下标别越界。
      for (int i = 0; i < a.length; i++) {
          System.out.println("数组中下标为" + i + "的元素是：" + a[i]);
      }
      // 初始化一个Object类型的数组，采用动态初始化方式
      Object[] objs = new Object[3]; // 3个长度，动态初始化，所以每个元素默认值是null
      for (int i = 0; i < objs.length; i++) {
          System.out.println(objs[i]);
      }
      System.out.println("===============================");
      String[] strs = new String[3];
      for (int i = 0; i < strs.length; i++) {
          System.out.println(strs[i]);
      }
      // 采用静态初始化的方式
      String[] strs2 = {"abc", "def", "xyz"};
      for (int i = 0; i < strs2.length; i++) {
          System.out.println(strs2[i]);
      }
      // 存储Object，采用静态初始化呢？
      /*Object o1 = new Object();
      Object o2 = new Object();
      Object o3 = new Object();
      Object[] objects = {o1, o2, o3};*/
      Object[] objects = {new Object(), new Object(), new Object()};
      for (int i = 0; i < objects.length; i++) {
          /*Object o = objects[i];
          System.out.println(o);*/
          System.out.println(objects[i]);
      }
     }
     }

2. 当一个方法上参数类型为数组时：
   自己总结的步骤：

   • 第一步：声明一个同类型的数组，并完成初始化。
   • 第二步：调用方法的形式参数为数组时，将声明后的同类型数组的名称，作为该方法的形式参数，传入即可。
   • 案例1：动态初始化后 再手动赋值

   • 如下：

     public class ArrayTest02 {
     public static void main(String[] args) {
      // 声明/定义一个数组，采用动态初始化的方式创建
      int[] a = new int[4]; // 创建长度为4的int数组，数组中每个元素的默认值是0
      // 遍历数组
      for (int i = 0; i < a.length; i++) {
          System.out.println("数组中下标为" + i + "的元素是：" + a[i]);
      }
      // 后期赋值
      a[0] = 1;
      a[1] = 100;
      a[2] = 111;
      a[3] = 222; // 注意下标别越界。
      for (int i = 0; i < a.length; i++) {
          System.out.println("数组中下标为" + i + "的元素是：" + a[i]);
      }
      // 初始化一个Object类型的数组，采用动态初始化方式
      Object[] objs = new Object[3]; // 3个长度，动态初始化，所以每个元素默认值是null
      for (int i = 0; i < objs.length; i++) {
          System.out.println(objs[i]);
      }
      System.out.println("===============================");
      String[] strs = new String[3];
      for (int i = 0; i < strs.length; i++) {
          System.out.println(strs[i]);
      }
      // 采用静态初始化的方式
      String[] strs2 = {"abc", "def", "xyz"};
      for (int i = 0; i < strs2.length; i++) {
          System.out.println(strs2[i]);
      }
      // 存储Object，采用静态初始化呢？
      /*Object o1 = new Object();
      Object o2 = new Object();
      Object o3 = new Object();
      Object[] objects = {o1, o2, o3};*/
      Object[] objects = {new Object(), new Object(), new Object()};
      for (int i = 0; i < objects.length; i++) {
          /*Object o = objects[i];
          System.out.println(o);*/
          System.out.println(objects[i]);
      }
     }
     }

3. 当方法的参数为数组时，用以下语法赋值

   • 案例二如下： ```java public class ArrayTest04 { public static void main(String[] args) { // 静态初始化一维数组 int[] a = {1,2,3}; printArray(a);

     System.out.println(“============================”); // 没有这种语法。 //printArray({1,2,3}); // 如果直接传递一个静态数组的话，语法必须这样写。 printArray(new int[]{1,2,3});

     // 动态初始化一维数组 int[] a2 = new int[4]; printArray(a2);

     System.out.println(“=============================”); printArray(new int[3]); }

   // 为什么要使用静态方法？方便呀，不需要new对象啊。 public static void printArray(int[] array){

   for (int i = 0; i < array.length; i++) {
       System.out.println(array[i]);
   }

   } } ```

String[] args

1. main方法上面的“String[] args”有什么用？

   • 分析如下：谁负责调用main方法（JVM）
     JVM调用main方法的时候，会自动传一个String数组过来

   • jVM默认传递过来的这个数组对象的长度？ 默认0

     • 这个数组什么时候里面会有值呢？
       其实这个数组是留给用户的，用户可以在控制台上输入参数，这个参数自动会被转换为“String[] args”

       例如这样运行程序：java ArrayTest05 abc def xyz

     • 那么这个时候JVM会自动将“abc def xyz”通过空格的方式进行分离，分离完成之后，自动放到“String[] args”数组当中。

     • 把abc def xyz 转换成字符串数组：{“abc”,”def”,”xyz”}
   • 所以main方法上面的String[] args数组主要是用来接收用户输入参数的。
   • 以下代码表示的含义：数组对象创建了，但是数组中没有任何数据。
     String[] strs = new String[0];
     String[] strs = {}; // 静态初始化数组，里面没东西。
2. 案例一如下：

public class ArrayTest05 {
    // 这个方法程序员负责写出来，JVM负责调用。JVM调用的时候一定会传一个String数组过来。
    public static void main(String[] args) {
        // JVM默认传递过来的这个数组对象的长度？默认0
        // 通过测试得出：args不是null。
        System.out.println("JVM给传递过来的String数组参数，它这个数组的长度是？" + args.length);
        // 以下这一行代码表示的含义：数组对象创建了，但是数组中没有任何数据。
        //String[] strs = new String[0];
        //String[] strs = {}; // 静态初始化数组，里面没东西。
        //printLength(strs);
        // 例如这样运行程序：java ArrayTest05 abc def xyz
        // 那么这个时候JVM会自动将“abc def xyz”通过空格的方式进行分离，分离完成之后，自动放到“String[] args”数组当中。
        // 所以main方法上面的String[] args数组主要是用来接收用户输入参数的。
        // 把abc def xyz 转换成字符串数组：{"abc","def","xyz"}
        // 遍历数组
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
    }
    public static void printLength(String[] args){
        System.out.println(args.length); // 0
    }
}

1. string[ ] args有什么作用？
   • 模拟一个系统，假设这个系统要使用，必须输入用户名和密码。

public class ArrayTest06 {
    // 用户名和密码输入到String[] args数组当中。
    public static void main(String[] args) {
        if(args.length != 2){
            System.out.println("使用该系统时请输入程序参数，参数中包括用户名和密码信息，例如：zhangsan 123");
            return;
        }
        // 程序执行到此处说明用户确实提供了用户名和密码。
        // 接下来你应该判断用户名和密码是否正确。
        // 取出用户名
        String username = args[0];
        // 取出密码
        String password = args[1];
        // 假设用户名是admin，密码是123的时候表示登录成功。其它一律失败。
        // 判断两个字符串是否相等，需要使用equals方法。
        //if(username.equals("admin") && password.equals("123")){
        // 这样编写是不是可以避免空指针异常。
        // 采用以下编码风格，及时username和password都是null，也不会出现空指针异常。（这是老程序员给的一条编程经验。）
        if("admin".equals(username) && "123".equals(password)){
            System.out.println("登录成功，欢迎[" + username + "]回来");
            System.out.println("您可以继续使用该系统....");
        }else{
            System.out.println("验证失败，用户名不存在或者密码错误！");
        }
    }
}

一维数组（二）

1. 一维数组的深入：
   • 一维数组的深入，数组中存储的类型为：引用数据类型
   • 对于数组来说，实际上只能存储java对象的“内存地址”。数组中存储的每个元素是“引用”
2. 数组中存储的是引用的的案例：

public class ArrayTest07 {
    public static void main(String[] args) {
        // a是一个数组
        // a[0] 是数组中的一个元素。
        // a[1] 是数组中的一个元素。
        int[] a = {100, 200, 300};
        System.out.println(a[1]);
        //a[2] = 400;
        int[] array = {1,2,3};
        for (int i = 0; i < array.length; i++) {
            /*int temp = array[i];
            System.out.println(temp);*/
            System.out.println(array[i]);
        }
        // 创建一个Animal类型的数组
        Animal a1 = new Animal();
        Animal a2 = new Animal();
        Animal[] animals = {a1, a2};
        // 对Animal数组进行遍历
        for (int i = 0; i < animals.length; i++) {
            /*Animal a = animals[i];
            a.move();*/
            // 代码合并
            animals[i].move(); // 这个move()方法不是数组的。是数组当中Animal对象的move()方法。
        }
        // 动态初始化一个长度为2的Animal类型数组。
        Animal[] ans = new Animal[2];
        // 创建一个Animal对象，放到数组的第一个盒子中。
        ans[0] = new Animal();
        // Animal数组中只能存放Animal类型，不能存放Product类型。
        //ans[1] = new Product();
        // Animal数组中可以存放Cat类型的数据，因为Cat是一个Animal。
        // Cat是Animal的子类。
        ans[1] = new Cat();
        // 创建一个Animal类型的数组，数组当中存储Cat和Bird
        Cat c = new Cat();
        Bird b = new Bird();
        Animal[] anis = {c, b};
        //Animal[] anis = {new Cat(), new Bird()}; // 该数组中存储了两个对象的内存地址。
        for (int i = 0; i < anis.length; i++){
            // 这个取出来的可能是Cat，也可能是Bird，不过肯定是一个Animal
            // 如果调用的方法是父类中存在的方法不需要向下转型。直接使用父类型引用调用即可。
            //anis[i]
            //Animal an = anis[i];
            //an.move();
            //Animal中没有sing()方法。
            //anis[i].sing();
            // 调用子对象特有方法的话，需要向下转型！！！
            if(anis[i] instanceof Cat){
                Cat cat = (Cat)anis[i];
                cat.catchMouse();
            }else if(anis[i] instanceof Bird){
                Bird bird = (Bird)anis[i];
                bird.sing();
            }
        }
    }
}
class Animal{
    public void move(){
        System.out.println("Animal move...");
    }
}
// 商品类
class Product{
}
// Cat是子类
class Cat extends Animal {
    public void move(){
        System.out.println("猫在走猫步！");
    }
    // 特有方法
    public void catchMouse(){
        System.out.println("猫抓老鼠！");
    }
}
// Bird子类
class Bird extends Animal {
    public void move(){
        System.out.println("Bird Fly!!!");
    }
    // 特有的方法
    public void sing(){
        System.out.println("鸟儿在歌唱！！！");
    }
}

数组的扩容与拷贝

1. 在java开发中，数组长度一旦确定不可变，那么数组满了怎么办？
   • 数组满了，需要扩容。
2. java中对数组的扩容是?
   • 先新建一个大容量的数组，然后将小容量数组中的数据一个一个拷贝到大数组当中。
3. 结论：
   • 数组扩容效率较低。因为涉及到拷贝的问题。所以在以后的开发中请注意：尽可能少的进行数组的拷贝。
   • 可以在创建数组对象的时候预估计以下多长合适，最好预估准确，这样可以减少数组的扩容次数。提高效率。
4. 数组的拷贝

• java中的数组是怎么进行拷贝的呢？
  System.arraycopy(5个参数);

   调用JDK System类中的 arraycopy 方法，来完成数组的拷贝

• 五个参数的说明：
  （拷贝源，拷贝源的起始位置下标，拷贝目标，拷贝目标的终止位置下表，拷贝起始位置到终止位置中间有几个元素）；
  注意事项：

  • 拷贝目标 用动态方式初始化
  • 下标是从0开始的
  • 拷贝目标的终止位置下表：就是从拷贝目标第几个元素开始拷贝

1. 课堂源码如下：

public class ArrayTest08 {
    public static void main(String[] args) {
        // java中的数组是怎么进行拷贝的呢？
        //System.arraycopy(5个参数);
        // 拷贝源（从这个数组中拷贝）
        int[] src = {1, 11, 22, 3, 4};
        // 拷贝目标（拷贝到这个目标数组上）
        int[] dest = new int[20]; // 动态初始化一个长度为20的数组，每一个元素默认值0
        // 调用JDK System类中的arraycopy方法，来完成数组的拷贝
        //System.arraycopy(src, 1, dest, 3, 2);
        // 遍历目标数组
        /*
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]); // 0 0 0 11 22 ... 0
        }
         */
        System.arraycopy(src, 0, dest, 0, src.length);
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }
        // 数组中如果存储的元素是引用，可以拷贝吗？当然可以。
        String[] strs = {"hello", "world!", "study", "java", "oracle", "mysql", "jdbc"};
        String[] newStrs = new String[20];
        System.arraycopy(strs, 0, newStrs, 0, strs.length);
        for (int i = 0; i < newStrs.length; i++) {
            System.out.println(newStrs[i]);
        }
        System.out.println("================================");
        Object[] objs = {new Object(), new Object(), new Object()};
        Object[] newObjs = new Object[5];
        // 思考一下：这里拷贝的时候是拷贝对象，还是拷贝对象的地址。（地址。）
        System.arraycopy(objs, 0, newObjs, 0, objs.length);
        for (int i = 0; i < newObjs.length; i++) {
            System.out.println(newObjs[i]);
        }
    }
}

二维数组

1. 关于java中的二维数组
   • 二维数组其实是一个特殊的一维数组，特殊在这个一维数组当中的每一个元素是一个一维数组。
2. 三维数组是什么？
   三维数组是一个特殊的二维数组，特殊在这个二维数组中每一个元素是一个一维数组。
   实际的开发中使用最多的就是一维数组。二维数组也很少使用。三维数组几乎不用。
3. 二维数组静态初始化
   int[ ] [ ] array = {{1,1,1},{2,3,4,5},{0,0,0,0},{2,3,4,5},{2,3,4,5},{2,3,4,5},{2,3,4,5}};
4. 书写格式：
   eg1:

   int array[][] ={
   {1,1,1},
   {2,2,2},
   {3,3,3}
   };

public class ArrayTest09 {
    public static void main(String[] args) {
        // 一维数组
        int[] array = {100, 200, 300};
        System.out.println(array.length); // 3
        System.out.println("=======================");
        // 二维数组
        // 以下代码当中：里面的是4个一维数组。
        int[][] a = {
                {100, 200, 300},
                {30, 20, 40, 50, 60},
                {6, 7, 9, 1},
                {0}
        };
        System.out.println(a.length); // 4
        System.out.println(a[0].length); // 3
        System.out.println(a[1].length); // 5
        System.out.println(a[2].length); // 4
        System.out.println(a[3].length); // 1
        // 里面的是5个一维数组。
        int[][] a2 = {
                {100, 200, 300},
                {30, 20, 40, 50, 60},
                {6, 7, 9, 1},
                {0},
                {1,2,3,4,5}
        };
    }
}

1. 关于二维数组中元素的：读 和 改
   a[二维数组中的一维数组的下标】[一维数组中的元素下标]
   a[0] [0]：表示第1个一维数组中的第1个元素。
   a[3 】[ 100 ]：表示第4个一维数组中的第101个元素。
   注意：对于a[3] [100】来说，其中 a[3] 是一个整体。[100]是前面a[3]执行结束的结果然后再下标100.
2. eg2：

public class ArrayTest10 {
    public static void main(String[] args) {
        // 二维数组
        int[][] a = {
                {34,4,65},
                {100,200,3900,111},
                {0}
        };
        // 请取出以上二位数中的第1个一维数组。
        int[] 我是第1个一维数组 = a[0];
        int 我是第1个一维数组中的第1个元素 = 我是第1个一维数组[0];
        System.out.println(我是第1个一维数组中的第1个元素);
        // 以下代码的由来是因为以上代码的合并导致的。
        System.out.println(a[0][0]);
        // 取出第2个一维数组当中第3个元素
        System.out.println("第二个一维数组中第三个元素：" + a[1][2]);
        // 取出第3个一维数组当中第1个元素
        System.out.println("第3个一维数组中第1个元素：" + a[2][0]);
        // 改
        a[2][0] = 11111;
        System.out.println(a[2][0]);
        // 注意别越界。
        //java.lang.ArrayIndexOutOfBoundsException
        //System.out.println(a[2][1]);
    }
}

java.lang.ArrayIndexOutOfBoundsException
下标越界异常

1. 二维数组的遍历
   eg3:

   public class ArrayTest11 {
   public static void main(String[] args) {
       // 二维数组
       String[][] array = {
               {"java", "oracle", "c++", "python", "c#"},
               {"张三", "李四", "王五"},
               {"lucy", "jack", "rose"}
       };
       // 遍历二维数组
       for(int i = 0; i < array.length; i++){ // 外层循环3次。（负责纵向。）
           String[] 一维数组 = array[i];
           // 负责遍历一维数组
           for(int j = 0; j < 一维数组.length; j++){
               System.out.print(一维数组[j] + " ");
           }
           // 输出换行符
           System.out.println();
       }
       // 合并代码
       for(int i = 0; i < array.length; i++){ // 外层循环3次。（负责纵向。）
           for(int j = 0; j < array[i].length; j++){
               System.out.print(array[i][j] + " ");
           }
           System.out.println();
       }
   }
   }

2. 动态初始化二维数组

int[][] array = new int[3][4];
// 3行4列。
// 3个一维数组，每一个一维数组当中4个元素。
```

1. 当方法的参数为数组时
   eg4 二维数组的遍历:

   // 静态初始化
       int[][] a = {{1,2,3,4},{4,5,6,76},{1,23,4}};
       printArray(a);
       // 没有这种语法
       //printArray({{1,2,3,4},{4,5,6,76},{1,23,4}});
       // 可以这样写。
       printArray(new int[][]{{1,2,3,4},{4,5,6,76},{1,23,4}});
   }
   public static void printArray(int[][] array){
       // 遍历二维数组。
       for (int i = 0; i < array.length; i++) {
           for (int j = 0; j < array[i].length; j++) {
               System.out.print(array[i][j] + " ");
           }
           System.out.println();
       }
   }
   }

   public class ArrayTest12 {
   public static void main(String[] args) {
       // 3行4列。
       // 3个一维数组，每一个一维数组当中4个元素。
       int[][] array = new int[3][4];
       // 二维数组遍历
       for (int i = 0; i < array.length; i++) { // 循环3次。
           for (int j = 0; j < array[i].length; j++) {
               System.out.print(array[i][j] + " ");
           }
           System.out.println();
       }
    }

day 23天作业

1. 编写程序，使用一维数组，模拟栈数据结构。
   要求：
   1、这个栈可以存储java中的任何引用类型的数据。
   2、在栈中提供push方法模拟压栈。（栈满了，要有提示信息。）
   3、在栈中提供pop方法模拟弹栈。（栈空了，也有有提示信息。）
   4、编写测试程序，new栈对象，调用push pop方法来模拟压栈弹栈的动作。
   5、假设栈的默认初始化容量是10.（请注意无参数构造方法的编写方式。）
   答案如下：

public class MyStack {
    // 向栈当中存储元素，我们这里使用一维数组模拟。存到栈中，就表示存储到数组中。
    // 因为数组是我们学习java的第一个容器。
    // 为什么选择Object类型数组？因为这个栈可以存储java中的任何引用类型的数据
    // new Animal()对象可以放进去，new Person()对象也可以放进去。因为Animal和Person的超级父类就是Object。
    // 包括String也可以存储进去。因为String父类也是Object。
    private Object[] elements;
    // 栈帧，永远指向栈顶部元素
    // 那么这个默认初始值应该是多少。注意：最初的栈是空的，一个元素都没有。
    //private int index = 0; // 如果index采用0，表示栈帧指向了顶部元素的上方。
    //private int index = -1; // 如果index采用-1，表示栈帧指向了顶部元素。
    private int index;
    /**
     * 无参数构造方法。默认初始化栈容量10.
     */
    public MyStack() {
        // 一维数组动态初始化
        // 默认初始化容量是10.
        this.elements = new Object[10];
        // 给index初始化
        this.index = -1;
    }
    /**
     * 压栈的方法
     * @param obj 被压入的元素
     */
    public void push(Object obj){
        if(index >= elements.length - 1){
            System.out.println("压栈失败，栈已满！");
            return;
        }
        // 程序能够走到这里，说明栈没满
        // 向栈中加1个元素，栈帧向上移动一个位置。
        index++;
        elements[index] = obj;
        // 在声明一次：所有的System.out.println()方法执行时，如果输出引用的话，自动调用引用的toString()方法。
        System.out.println("压栈" + obj + "元素成功，栈帧指向" + index);
    }
    /**
     * 弹栈的方法，从数组中往外取元素。每取出一个元素，栈帧向下移动一位。
     * @return
     */
    public void pop(){
        if(index < 0){
            System.out.println("弹栈失败，栈已空！");
            return;
        }
        // 程序能够执行到此处说明栈没有空。
        System.out.print("弹栈" + elements[index] + "元素成功，");
        // 栈帧向下移动一位。
        index--;
        System.out.println("栈帧指向" + index);
    }
    // set和get也许用不上，但是你必须写上，这是规矩。你使用IDEA生成就行了。
    // 封装：第一步：属性私有化，第二步：对外提供set和get方法。
    public Object[] getElements() {
        return elements;
    }
    public void setElements(Object[] elements) {
        this.elements = elements;
    }
    public int getIndex() {
        return index;
    }
    public void setIndex(int index) {
        this.index = index;
    }
}

public class MyStackTest {
    public static void main(String[] args) {
        // 创建一个栈对象，初始化容量是10个。
        MyStack stack = new MyStack();
        // 调用方法压栈
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object()); // 最后压入的。最先弹出来。（这个才符合栈的数据结构。）
        // 压这个元素失败了。
        stack.push(new Object());
        // 弹栈
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
    }
}

1. 为某个酒店编写程序：酒店管理系统，模拟订房、退房、打印所有房间状态等功能。
   1、该系统的用户是：酒店前台。
   2、酒店使用一个二维数组来模拟。“Room[][] rooms;”
   3、酒店中的每一个房间应该是一个java对象：Room
   4、每一个房间Room应该有：房间编号、房间类型、房间是否空闲.
   5、系统应该对外提供的功能：
   可以预定房间：用户输入房间编号，订房。
   可以退房：用户输入房间编号，退房。
   可以查看所有房间的状态：用户输入某个指令应该可以查看所有房间状态。

答案如下：

public class HotelMgtSystem {
    public static void main(String[] args) {
        // 创建酒店对象
        Hotel hotel = new Hotel();
        // 打印房间状态
        //hotel.print();
        /*
        首先输出一个欢迎页面
         */
        System.out.println("欢迎使用酒店管理系统，请认真阅读以下使用说明");
        System.out.println("功能编号对应的功能：[1]表示查看房间列表。[2]表示订房。[3]表示退房。[0]表示退出系统。");
        Scanner s = new Scanner(System.in);
        // 一直可以使用（死循环。）。
        while(true){
            System.out.print("请输入功能编号：");
            int i = s.nextInt();
            if(i == 1){
                // 查看房间列表
                hotel.print();
            }else if(i == 2){
                // 订房
                System.out.print("请输入订房编号：");
                int roomNo = s.nextInt(); //小姐姐输入房间编号
                hotel.order(roomNo);
            }else if(i == 3){
                // 退房
                System.out.print("请输入退房编号：");
                int roomNo = s.nextInt(); //小姐姐输入房间编号
                hotel.exit(roomNo);
            }else if(i == 0){
                // 退出系统
                System.out.println("再见，欢迎下次再来！");
                return;
            }else{
                // 出错了！
                System.out.println("输入功能编号有误，请重新输入！");
            }
        }
    }
}

/*
酒店对象，酒店中有二维数组，二维数组模拟大厦。
 */
public class Hotel {
    /**
     * 二维数组，模拟大厦所有的房间
     */
    private Room[][] rooms;
    // 盖楼通过构造方法来盖楼。
    public Hotel(){
        // 一共有几层，每层的房间类型是什么，每个房间的编号是什么。
        // 我们可以先写死。一共三层、一层单人间、二层标准间、三层总统套房，每层有10个房间。
        /**
         * 房间编号
         * 1楼：101 102 103 104 105 106..
         * 2楼：201 202 203 204 205 206..
         * 3楼：301 302 303 304 305 306..
         * ...
         */
        // 动态初始化
        rooms = new Room[3][10]; // 3行10列。3层楼，每层10个房间。
        // 创建30个Room对象，放到数组当中。
        // 怎么放？ 二维数组遍历。
        for(int i = 0; i < rooms.length; i++){ // i是下标：0 1 2。i+1是楼层：1,2,3
            for(int j = 0; j < rooms[i].length; j++){
                if(i == 0){
                    // 一层
                    rooms[i][j] = new Room((i+1)*100+j+1, "单人间", true);
                }else if(i == 1){
                    // 二层
                    rooms[i][j] = new Room((i+1)*100+j+1, "标准间", true);
                }else if(i == 2){
                    // 三层
                    rooms[i][j] = new Room((i+1)*100+j+1, "总统套房", true);
                }
            }
        }
    }
    // 在酒店对象上提供一个打印房间列表的方法
    public void print(){
        // 打印所有房间状态,就是遍历二维数组
        for(int i = 0; i < rooms.length; i++){
            // 里面for循环负责输出一层。
            for(int j = 0; j < rooms[i].length; j++) {
                Room room = rooms[i][j];
                System.out.print(room);
            }
            // 换行
            System.out.println();
        }
    }
    /**
     * 订房方法。
     * @param roomNo 调用此方法时需要传递一个房间编号过来。这个房间编号是前台小姐姐输入的。
     */
    public void order(int roomNo){
        // 订房最主要的是将房间对象的status修改为false。
        // Room对象的status修改为false。
        // 假设房间编号207（下标是 rooms[1][6] ）
        // 通过房间编号演算出下标。获取房间对象。
        Room room = rooms[roomNo / 100 - 1][roomNo % 100 - 1];
        // 修改为占用。
        room.setStatus(false);
        System.out.println(roomNo + "已订房！");
    }
    /**
     * 退房
     * @param roomNo
     */
    public void exit(int roomNo){
        Room room = rooms[roomNo / 100 - 1][roomNo % 100 - 1];
        // 修改为空闲。
        room.setStatus(true);
        System.out.println(roomNo + "已退房！");
    }
}