面向对象:
所谓面向对象它是针对于面向过程来说的,面向过程是在意执行的流程。而面向对象在意的功能。将一系列的过程封装到一个容器中,我们通过操作这个容器即以对象的方式来进行操作就是面向对象。
类:
类是一类事物的总称,它是看不见摸不着的。如:空气、人。它们都看不见,也摸不着,但是又真实存在。
对象:
对象是看得见摸得着的,它是类的一个具体的实例。一个类可以创建多个实例对象。
1、类
1.1 类的创建
类的创建一般分为以下三步:
-
类的名称
-
类的属性(类的特征)
-
类的行为(动作,也叫方法)
示例:我们定义一个人的类,它有身高、体重、性别、年龄等;同时它也具有吃、跑、走等行为。
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.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;
}
注意:
- static关键字可以修改方法,也可以修改属性,但是不能修改变量
- static关键字修改的方法可以通过
类名.方法名()
来访问,修饰的属性可以通过类名.属性名
来访问 -
被static修改的方法叫类方法,被statis修饰的属性叫类属性,因此可以通过
类名.
的方式来使用 -
在 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);
}
}