一、预备知识

1. setter/getter方法

public	private
公共的	私有的
外部可以直接访问这个属性或者方法	不希望外部访问这个对象的一些属性或方法
使用对象可以直接调用	只能间接使用

定义Poker类：

class Poker{
    private String number;
    private String color;


    //给外部提供一个set方法 通过这个方法间接给number赋值
    //可以对外部给的值进行控制
    public void setNumber(String number){
        this.number = number;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    //给外部提供一个get方法访问某个变量的值
    //封装内部实现
    public String getNumber(){
        return number;
    }

}

setter/getter方法的使用:

        //创建对象
        Poker poker = new Poker();
        poker.setNumber("jack");
        System.out.println(poker.getNumber());

• 1. Alt+insert 快速产生setter getter方法

• 2. 建议将setter/getter方法定义在类的最后面 ,避免干扰阅读

• 3. 成员变量的作用域，从对象的创建到对象被销毁

image.png

2. 构造方法（在对象被创建时调用）

• 希望在对象创建的时候 做点其他事

• 在创建对象的时候，需要给属性赋值，自定义构造方法

image.png

调用：

调用

输出结果：

输出结果

• 构造方法的重载：同一个类里面有多个同名的方法，但是返回值或者参数不同，如public int nextInt() 和public int nextInt(int i)

3. static的用法

• static:修饰的属性和方法，都会在对象创建之前在静态区里面优先加载

实例方法/对象方法：必需创建一个对象才能调用的方法

类方法/静态方法：不需要创建对象 直接用这个类调用

静态属性：1. 定义一个常量 只能赋值一次  2.单例设计模式

class MyClass{
    public String name;
    public static String address;

    public void test(){
        System.out.println("这是对象方法");
    }

    public static void test2(){
        System.out.println("这是静态方法");
    }
}
class T2{
    public static void main(String[] args){
        //使用类的类的实例方法/对象方法
        MyClass c1 = new MyClass();
        c1.test();

        //使用类方法/静态方法
        MyClass.test2();

        //调用静态属性
        MyClass.address = "jack";
       
    }
}

什么情况下使用静态方法：

1. 工厂设计模式Factory
2. 当不需要记录数据的时候 只关心功能就可以使用静态方法
   注意：一个静态方法里面不能调用这个类的非静态属性和非静态方法

4. this的用法

1. 什么时候用this：需要明确指定调用的是这个对象自己的一些属性或者方法

2. this可以指创建的这个对象，也可以只调用这个方法的对象

image.png image.png

5. ArrayList(动态数组)的使用

• 什么是ArrayList

  ArrayList就是传说中的动态数组，用MSDN中的说法，就是Array的复杂版本。当我们不知道到底有多少个数据元素的时候，就可使用ArrayList；如果知道数据集合有多少个元素，就用数组。

• 如何构建ArrayList

  • 构造方法：ArrayList<String> list = new ArrayList<String>();

• ArrayList常用方法

增加元素到链表中

• boolean add(Element e)
  增加指定元素到链表尾部.
• void add(int index, Element e)
  增加指定元素到链表指定位置.

从链表中删除元素

• void clear()
  从链表中删除所有元素.
• E remove(int index)
  删除链表中指定位置的元素.
• protected void removeRange(int start, int end)
  删除链表中从某一个位置开始到某一个位置结束的元素。

获取链表中的元素

• E get(int index)
  获取链表中指定位置处的元素.
• Object[] toArray()
  获取一个数组，数组中所有元素是链表中的元素.（即将链表转换为一个数组）

修改某个元素

• E set(int index, E element)
  将链表中指定位置上的元素替换成新元素。

搜索元素

• boolean contains(Object o)
  如果链表包含指定元素，返回true.
• int indexOf(Object o)
  返回元素在链表中第一次出现的位置，如果返回-1，表示链表中没有这个元素。
• int lastIndexOf(Object o)
  返回元素在链表中最后一次出现的位置，如果返回-1，表示链表中没有这个元素。

检查链表是否为空

• boolean isEmpty()
  返回true表示链表中没有任何元素.

获取链表大小

• int size()
  返回链表长度（链表包含元素的个数）.

6. 引用类型和基本数据类型的区别

• 基本数据类型

  • byte：Java中最小的数据类型，在内存中占8位(bit)，即1个字节，取值范围-128~127，默认值0

  • short：短整型，在内存中占16位，即2个字节，取值范围-32768~32767，默认值0

  • int：整型，用于存储整数，在内在中占32位，即4个字节，取值范围-2147483648~2147483647，默认值0

  • long：长整型，在内存中占64位，即8个字节-2^63~263-1，默认值0L

  • float：浮点型，在内存中占32位，即4个字节，用于存储带小数点的数字（与double的区别在于float类型有效小数点只有6~7位），默认值0

  • double：双精度浮点型，用于存储带有小数点的数字，在内存中占64位，即8个字节，默认值0

  • char：字符型，用于存储单个字符，占16位，即2个字节，取值范围0~65535，默认值为空

  • boolean：布尔类型，占1个字节，用于判断真或假（仅有两个值，即true、false），默认值false

• 引用数据类型:类、接口类型、数组类型、枚举类型、注解类型。

• 区别：

  • 基本数据类型在被创建时，在栈上给其划分一块内存，将数值直接存储在栈上。

  • 引用数据类型在被创建时，首先要在栈上给其引用（句柄）分配一块内存，而对象的具体信息都存储在堆内存上，然后由栈上面的引用指向堆中对象的地址。

7. 单例设计模式

（1）将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。

（2）在该类内部产生一个唯一的实例化对象，并且将其封装为private static类型。

（3）定义一个静态方法返回这个唯一对象。

• 实现一、立即加载 / “饿汉模式”

//饿汉模式
class Poker{
    //default,sharedInstance,manager
    //2.定义一个静态的成员变量 记录单例对象
    public static final Poker shared = new Poker();

    //1.私有化默认构造函数
    private Poker(){}

//3.  静态方法返回该实例
public static Poker getInstance() {
    return shared;
}

}

• 实现二、延迟加载 / “懒汉模式”

//懒汉模式
class Player{
    public int count = 0;
    //2.创建静态变量  这里没有final
    private static Player shared = null;

    //1.类的构造方法私有化
    private Player(){}

    //3.提供给外部一个访问方法
    public static  Player getInstance(){   //线程安全的懒汉模式
            if (shared == null) {
                //如果没有创建  那么就创建一个
                shared = new Player();
            }
      return shared;
    }

• 实现三、线程安全的“懒汉模式”

class Player{
    public int count = 0;
    //2.创建静态变量
    private static Player shared = null;

    //1.类的构造方法私有化
    private Player(){}

    //3.提供给外部一个访问方法
    public static  Player getInstance(){   //线程安全的懒汉模式
        Object b = new Object();
        synchronized (b) {
            if (shared == null) {
                //如果没有创建  那么就创建一个
                shared = new Player();
            }
        }
        return shared;
    }

二、心得体会

  demo的知识点主要就是这些了，想要知道怎么真正地与项目结合在一起，敬请期待接下来的更新！