JavaSE面向对象

面向对象：

所谓面向对象它是针对于面向过程来说的，面向过程是在意执行的流程。而面向对象在意的功能。将一系列的过程封装到一个容器中，我们通过操作这个容器即以对象的方式来进行操作就是面向对象。

类：

类是一类事物的总称，它是看不见摸不着的。如：空气、人。它们都看不见，也摸不着，但是又真实存在。

对象：

对象是看得见摸得着的，它是类的一个具体的实例。一个类可以创建多个实例对象。

1、类

1.1 类的创建

类的创建一般分为以下三步：

1. 类的名称

2. 类的属性（类的特征）

3. 类的行为（动作，也叫方法）

示例：我们定义一个人的类，它有身高、体重、性别、年龄等；同时它也具有吃、跑、走等行为。

public class Person {
    float height; // 身高
    float weight; // 体重
    String gender; // 性别
    int age; // 年龄

    public void speak() {
        System.out.println("身高: " + height + ", 体重：" + weight + ", 性别: " + gender + ", 年龄：" + age);
        //return null; // 报错
        return;
    }

    public int getAge() {
        return age;
    }

    // 带有参数的方法，如果参数有多个，则使用逗号进行分隔
    public void say(String str) {
        System.out.println(str);
    }
}

1.2 类的使用

使用语法：

类名称 引用名称 = new 类名称();

public class PersonDemo {
    public static void main(String[] args) {
        // 1. 创建对象
        Person person = new Person();
        // 2. 给对象中的属性赋值
        person.height = 185.1f;
        person.weight = 125.5f;
        person.gender = "男";
        person.age = 18;

        person.speak();

    }
}

问：在类中定义的属性与变量有什么区别？

答：

1. 定义的位置不同：属性是定义在类中，而变量是定义在方法中的。

2. 在内存中的位置不同：属性是在堆中的，而变量是在栈中。

3. 声明的周期不同：属性是在对象创建是放到堆中的且会随着对象的消失而消失，而变量是在栈中且方法执行后就消失。

4. 初始化不同：属性是在对象创建时初始化，而变量是在定义时就初始化。

1.3 封装

在 Java 中封装是面向对象三大特征之一。它的作用就是让程序的安全性得以提高。

所谓封装就是将对象的属性隐藏起来，不让外界直接访问，而是通过指定的方法来访问对象的属性，就叫封装。即在定义类的时候将属性私有化，通过 get方法和 set方法来访问类中的私有属性。

使用场景：写实体类时，但凡有属性都需要进行封装。从而来提高安全性

3、

1.4 构造函数

在一个类中，如果方法名和类名相同，并且这个方法没有返回值类型，则该方法就叫构造方法（也叫构造函数，还叫构造器）

构造器作用：给对象中的属性进行初始化

class Human {
    String name;
    private int age;

    // 构造器
    public Human(){

    }
    public Human(String n, int a) {
        name = n;
        age = a;
    }

    // 普通方法
    public void human() {

    }

}

1.5 static 关键字

static 可使类中的方法能够通过 类名.方法名()或类名.属性名 的方式来进行访问

static 关键字必须放在方法返回值类型之前，访问修饰符之后（高版本中不成立）

    static String name;
    private static int age;

	public static int  getAge() {
        return age;
    }

注意：

1. static关键字可以修改方法，也可以修改属性，但是不能修改变量
2. static关键字修改的方法可以通过 类名.方法名() 来访问，修饰的属性可以通过 类名.属性名 来访问

3. 被static修改的方法叫类方法，被statis修饰的属性叫类属性，因此可以通过 类名.的方式来使用

4. 在 static 修饰的方法中不能使用非静态的变量。

不能使用的原因：因为被 static 修饰的方法和属性它们的生命周期与类的生命周期相同。而非静态的方法和属性的生命周期是在创建这个对象时才有的。换句话说：被 static 修饰的成员的生命周期要比非静态的成员的生命周期长。

1.5.1 static 运用——单例设计模式

static 的一个经典运用场景就是单例设计模式。而单例设计模式分为懒汉式和饿汉式。

单例模式的特点：

• 构造方法私有化

• 提供私有的静态成员

• 提供公有的访问方法

单例设计模式所创建的对象不管有多少个，在内存中只有一份。

1）饿汉式

/**
 * 饿汉单例设计模式
 */
class Singleton1 {
    // 2. 提供私有静态成员
    private static Singleton1 instance = new Singleton1();
    // 1. 构造方法私有化
    private Singleton1() {}

    // 3. 提供静态公共方法
    public static Singleton1 getInstance() {
        return instance;
    }
}
public class SingletonTest1 {
    public static void main(String[] args) {
        Singleton1 s1 = Singleton1.getInstance();
        Singleton1 s2 = Singleton1.getInstance();
        System.out.println(s1 == s2); // true
    }
}

2）懒汉式

/**
 * 懒汉式
 */
class Singleton2 {
    private static Singleton2 instance;
    private Singleton2(){}
    public static Singleton2 getInstance(){
        if(instance == null){
            synchronized (Singleton2.class) {
                if (instance == null){
                    instance = new Singleton2();
                }
            }
        }
        return instance;
    }
}
public class SingletonTest2 {
    public static void main(String[] args) {
        Singleton2 s1 = Singleton2.getInstance();
        Singleton2 s2 = Singleton2.getInstance();
        System.out.println(s1 == s2);
    }
}