类和对象简介

📔 类和对象
📄 客观存在的事物都可以看作对象;
📄 类是对现实生活中一类具有共同属性和行为的事物的抽象；
📄 对象是能够看得见摸得着的真实存在的实体。

📔 类的定义
📄 类是Java程序的基本单位；
📄 类的组成：属性和行为

1. 属性：在类中通过成员变量来体现（类中方法外的变量）；
2. 行为：在类中通过成员方法来体现（和前面的方法相比去掉static即可）；

📔 类的定义步骤

1. 定义类；
2. 编写类的成员变量；
3. 编写类的成员方法；

   public class ClassName{
    //成员变量
    变量1的数据类型 变量1；
    变量2的数据类型 变量2；
    ……
    //成员方法
    方法1；
    方法2；
    ……
   }
   /*创建对象 *类名 对象名 = new 类名(); */

面向对象中的内存分配

📔 对象内存
📄 **Student s = new Student();**
📄 其中，s 指向栈内存，new Student() 地址在堆内存中；

📔 类中成员变量和局部变量区别

封装

📔 private关键字
📄 权限修饰符；
📄 可以修饰成员（成员变量和成员方法）；
📄 作用是保护成员不被别的类使用，被private修饰的成员只能在本类中才能访问；

📔 this关键字
📄 this修饰的变量指代成员变量；
📄 解决局部变量隐藏的成员变量；
📄 代表所在类对象的引用；

📔 封装
📄 将某些信息隐藏在类内部，不允许外部直接访问，必须通过方法访问；
📄 提高安全性；

构造方法

📔 构造方法又叫做构造器，是类的一个特殊成员，它会在类实例化对象的时候自动调用；
📄 作用：创建对象；
📄 功能：创建对象时完成初始化；
📄 语法：

[修饰符] 方法名 ([参数列表]){
    //方法体
}

📔 构造方法注意事项
📄 当类中没有构造方法时，系统会默认生成一个无参的方法；
📄 构造方法创建：

1. 如果没有定义构造方法，系统将给出一个默认的无参数构造方法；
2. 如果定义了构造方法，系统将不再提供默认的构造方法；

📄 构造方法重载：如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法；
📄 推荐形式：无论是否使用，都手工书写无参的构造方法；

📔 API(Application Programming Interface)：应用程序编程接口（们只需关注使用方法，不需要关注其实现的过程。）

String类

📄 String类在java.lang包下，所以使用的时候不需要导包；
📄 String类代表字符串，Java程序中的所有字符串文字都被实现为此类的实例，也就是说，Java程序中所有的使用双引号的字符串，都是String类的对象;

字符串的特点

📄 字符串不可改变，它们的值在创建后不能被更改；
📄 虽然String的值不能被更改，但是它们可以被共享；
📄 字符串效果上相当于字符数组（char[]）——jdk8及以前是字符数组，jdk9及以后是字节数组，但是底层原理是字节数组(byte[]);

String s1 = new String();
System.out.println("s1:" + s1);
/*控制台输出：
    s1:
*/

char[] chs = {'a','b','c'};
String s2 = new String(chs);
System.out.println("s2:" + s2);
/*控制台输出
    s2:abc
*/

byte[] bys = {97,98,99};    //字节直接输入整数
String s3 = new String(bys);
System.out.println("s3:" + s3);
/*控制台输出
    s3:abc
*/

String s4 = "abc";
System.out.println("s4:" + s4);
/*控制台输出
    s4:abs
*/

String 对象的特点

1. 通过new创建的字符串对象，每一次new都会申请一个内存空间，虽然内容相同，但是地址不同；
2. 以 “” 给出的字符串对象，只要字符序列相同（顺序和大小写），无论在程序代码中出现多少次，JVM都只会建立一个String对象，并在字符串池中维护。

字符串比较

📔 使用 == 做比较
📄 基本类型：比较的是数据值是否相同；
📄 引用类型：比较的是地址值是否相同；

📔 字符串是对象，它比较内容是否相同，是通过一个方法来实现的，这个方法叫做：**equals()**；
📄**public boolean equals(Object anObject)**: 将此字符串与指定对象进行比较。由于我们比较的是字符串对象，所以参数直接传递一个字符串。

public static void main(String[] args) {
        char[] chs = {'a','b','c'};
        String s1 = new String(chs);
        String s2 = new String(chs);
        String s3 = "abc";
        String s4 = "abc";
        System.out.println("s1 and s2:" + (s1 == s2));
        System.out.println("s1 and s3:" + (s1 == s3));
        System.out.println("s3 and s4:" + (s3 == s4));
        System.out.println("_____________________");
        //比较内容
        System.out.println("s1 and s2:" + s1.equals(s2));
        System.out.println("s1 and s3:" + s1.equals(s3));
        System.out.println("s3 and s4:" + s3.equals(s4));
    }
/*控制台输出：
s1 and s2:false
s1 and s3:false
s3 and s4:true
_____________________
s1 and s2:true
s1 and s3:true
s3 and s4:true
*/

String 中的方法

StringBuilder

public static void main(String[] args){
    String s = "hello";
    s += "world";
    System.out.println(s);
}

📔 在此段代码中，在堆内存中：

1. 首先在常量池中，生成一个 **"hello"** 字段；
2. 再在常量池中生成 **"world"** 字段；
3. 最后再生成 **"helloworld"** 字段；

📄 即生成了三个字段，这种操作耗费空间；Java提供了 StringBuilder 类来避免这种操作。

1. **StringBuilder** 是一个可变的字符串类，我们把它看成一个容器；
2. 这里的可变指的是 **StringBuilder** 对象中的内容是可变的；
3. **StringBuilder** 和 **String** 类的区别：
   1. **String**：内容不可变；
   2. **StringBuilder**：内容可变；

StringBuilder 的构造方法

📔 同一般的类的构造方法；

StringBuilder 类中的方法使用

📔 **append()**方法：添加数据，返回对象本身；

    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("Hello ");
        sb.append("World");
        System.out.println("sb:" + sb);
    }
    /*控制台输出
    sb:Hello World
    */

    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        //链式编程
        sb.append("Hello ").append("World");
        System.out.println("sb:" + sb);
    }
    /*控制台输出
    sb:Hello World
    */

📔 **reverse()** 反转方法：

    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("Hello ");
        sb.append("World");
        sb.resver();
        System.out.println("sb:" + sb);
    }
    /*控制台输出
    sb:dlroW olleH
    */

StringBuilder 和 String 相互转换

📄 StringBuilder 转化为 String 使用 **toString()** 方法；
📄 String 转化为 StringBuilder 通过构造方法实现;

    public static void main(String[] args) {
        //StringBuilder 转化为 String
        StringBuilder sb = new StringBuilder();
        sb.append("Hello World");
        String s = sb.toString();
        System.out.println("s:" + s);
        //String 转化为 StringBuilder 
        String s1 = "Hello World";
        StringBuilder sb1 = new StringBuilder(s1);
        System.out.println("sb1:" + sb1);
    }
/*控制台输出：
s:Hello World
sb1:Hello World
*/

集合基础

📔 集合的特点：提供一种存储空间可变的存储模型，存储的数据容量可以方法改变；
📄 集合类很多，介绍 ArrayList

📔 使用之前要导包
📄**ArrayList<E>**

1. 可调整大小的数组实现
2. **<E>**：是一种特殊的数据类型，泛型；
3. 在出现的地方使用引用数据类型替换即可；

📃**ArrayList<String>**；
📃**ArrayList<Student>**；

📑 插入元素不能索引越界，最多只能多一个位置——即有2个元素，则索引为0，1；插入位置最多只能2，不能超过2；

import java.util.ArrayList;
public class day11_test3 {
    public static void main(String[] args) {
        //jdk1.7后新特性，new 后面的<>中类型可以自动从前面推导
        ArrayList<String> array = new ArrayList<>();
        //使用 add()方法添加元素
        array.add("Hello");
        array.add("World");
        System.out.println("array:" + array);
        //使用 public void add(int index,E element)在指定位置添加(插入)元素
        array.add(1, "javaSE");
        System.out.println("array:" + array);
    }
}
/*控制台输出：
array:[Hello, World]
array:[Hello, javaSE, World]
*/

📔 ArrayList 常用方法