面向对象：

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

类：

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

对象：

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

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