Java语言基础——面向对象（上）_java语言面相对象基础-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_50570968/article/details/108451546

1. 面向对象

1.1 面向对象思想

Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下，使用Java语言去设计、开发计算机程序。这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。

举例：洗衣服
面向过程：把衣服脱下来–>找一个盆–>放点洗衣粉–>加点水–>浸泡10分钟–>揉一揉–>清洗衣服–>拧干–>晾起来

面向对象：把衣服脱下来–>打开全自动洗衣机–>扔衣服–>按钮–>晾起来
区别:

面向过程：强调步骤
面向对象：强调对象，这里的对象就是洗衣机

特点：面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。面向对象的语言中，包含了三大基本特征，即封装、继承和多态。

1.2 类和对象

什么是类？类是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。

现实中，描述一类事物：
①属性：就是该事物的状态信息
②行为：就是该事物能够做什么
举例：小猫。
①属性：名字、体重、年龄、颜色等
②行为：走、跑、叫
什么是对象？对象是一类事物的具体体现。对象是类的一个实例，必然具备该类事物的属性和行为。

1.3 类与对象的关系

①类是对一类事物的描述，是抽象的
②对象是一类事物的实例，是具体的
③类是对象的模板，对象是类的实体

2. 类和对象

事物与类的对比
①现实世界的一类事物。属性：事物的状态信息。行为：事物能够做什么。
②Java中用class描述事物也是如此。成员变量：对应事物的属性；成员方法：对应事物的行为

2.1 类的定义格式

public class ClassName { 
    //成员变量
    //成员方法
}

定义类：就是定义类的成员，包括成员变量和成员方法。
成员变量：和以前定义变量几乎是一样的。只不过位置发生了改变。在类中，方法外。
成员方法：和以前定义方法几乎是一样的。

2.2 对象的使用

创建对象：

类名 对象名 = new 类名();

使用对象访问类中的成员：

对象名.成员变量;
对象名.成员方法();

2.3 成员变量的默认值

	数据类型	默认值
基本类型	整数（byte，short，int，long）	0
	浮点数（float，double）	0.0
	字符（char）	‘\u0000’
	布尔（boolean）	false
引用类型	数组，类，接口	null

2.4 对象内存图

一个对象，调用一个方法内存图
在这里插入图片描述
通过上图，我们可以理解，在栈内存中运行的方法，遵循"先进后出，后进先出"的原则。变量p指向堆内存中的空间，寻找方法信息，去执行该方法。

2.5 成员变量和局部变量区别

变量根据定义位置的不同，我们给变量起了不同的名字。如下图所示：
在这里插入图片描述
①在类中的位置不同(重点)
成员变量：类中，方法外
局部变量：方法中或者方法声明上(形式参数)
②作用范围不一样(重点)
成员变量：类中
局部变量：方法中
③初始化值的不同(重点)
成员变量：有默认值
局部变量：没有默认值。必须先定义，赋值，最后使用
④在内存中的位置不同(了解)
成员变量：堆内存
局部变量：栈内存
⑤生命周期不同(了解)
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

3. 封装

面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。

3.1 private关键字

概念：private是一个权限修饰符，代表最小权限。可以修饰成员变量和成员方法。被private修饰后的成员变量和成员方法，只在本类中才能访问。

3.2 构造方法

特点：①方法名与类名相同 ②没有返回类型 ③没有返回值
作用：构造方法是用于创建对象，并对其进行初始化赋值，对象一建立就自动调用相对应的构造方法
如果一个自定义类没有构造方法，系统会默认给出一个无参构造方法。

3.3 this关键字

this关键字代表本类对象的引用，谁调用this所在的方法，this就代表谁。
在定义方法时，该方法内部要用到调用该方法的对象时，因为此时对象还没建立，所以JDK官方提供this关键字给我们，this就代表了此对象。

3.4 封装的步骤

①使用private关键字来修饰成员变量
②提供构造方法
③对需要访问的成员变量，提供对应的一对set和get方法

public class Student { 
    private String name; 
    private int age; 
    public Student() { //无参数构造方法 
        super();
    }
    public Student(String name,int age) {  //有参数构造方法 
        this.name = name; //this代表本类对象的引用
        this.age = age; 
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Int getAge() {
        return age;
    }
}

注意事项：
①如果你不提供构造方法，那么系统会给出无参数构造方法。
②如果你提供了构造方法，系统将不再提供无参数构造方法，并且无参构造方法也不能再使用。
③构造方法是可以重载的，既可以定义参数，也可以不定义参数。

Student s = new Student();在内存中做了哪些事情？

①首先将Student.class文件加载进内存中。
②如果s定义在主方法中，那么就会在栈内存中开辟一个空间给变量p。
③在堆内存中给对象分配空间。
④对对象中的成员进行默认初始化。
⑤对对象中的成员进行显示初始化。
⑥调用构造代码块对对象进行初始化。(如果没有就不执行)
⑦调用构造方法对对象进行初始化。对象初始化完毕。
⑧将对象的内存地址赋值给s变量，让s变量指向该对象。

标准代码–JavaBean
JavaBean是Java语言编写类的一种标准规范。符合JavaBean的类，要求类必须是具体的和公共的，并且具有无参数的构造方法，提供用来操作成员变量的set和get方法。

public class Student {
   	//成员变量
   	//无参构造方法[必须] 
   	//有参构造方法[建议] 
   	//getXxx() 
   	//setXxx()
}

4. 静态

static用来修饰成员变量和成员方法
静态的特点:
①随着类的加载而加载 ②优先于对象存在 ③对所有对象共享 ④可以被类名直接调用

4.1 静态的注意事项

①静态方法只能访问静态成员。因为静态的内容是随着类的加载而加载，它是先进内存的。静态方法是属于类的方法，而普通方法是属于对象的方法。属于类的静态方法可以在对象不存在的时候就能访问到，而普通方法必须先new一个对象才能用这个对象访问。
②静态方法中不能使用this和super关键字
在这里插入图片描述

4.2 静态变量和成员变量的区别

①调用方式
静态变量也称为类变量，可以直接通过类名调用，也可以通过对象名调用(不推荐)。这个变量属于类。
成员变量也称为实例变量，只能通过对象名调用。这个变量属于对象。

②存储位置
静态变量存储在方法区中的静态区。
成员变量存储在堆内存。

③生命周期
静态变量随着类的加载而存在，随着类的消失而消失。生命周期长。
成员变量随着对象的创建而存在，随着对象的消失而消失。

④与对象的相关性
静态变量是所有对象共享的数据。
成员变量是每个对象所特有的数据。

静态的优点和弊端
优点：对对象的共享数据进行单独空间的存储，节省内存，没有必要每个对象都存储一份，可以直接被类名调用
弊端：生命周期过长，随着类的消失而消失。访问出现权限，即静态虽好但只能访问静态

静态什么时候使用？
①当所有对象共享某个数据的时候，就把这个成员变量定义为静态修饰的。
②当某个方法没有访问该类中的非静态成员时，就可以把这个方法定义为静态修饰。
静态的生命周期比较长，所以一般不推荐使用

4.3 静态代码块

语法格式：

static {
	   静态代码块中的语句;
}

它只执行一次，它比main方法还先执行。

静态代码块一般用于加载配置文件。

5. final关键字

是一个修饰符。可以修饰类，方法，变量。
特点：
①被final修饰的类不能被继承
②被final修饰的方法不能被重写
③被final修饰的变量是一个常量只能赋值一次。当这个值不需要改变时，可以用final来修饰，作为常量。

6. 权限修饰符

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限。

public：公共的
protected：受保护的
default：默认的
private：私有的

修饰符的访问权限

	public	protected	default	private
同一类中	√	√	√	√
同一包中	√	√	√
不同包中的子类	√	√
不同包中的无关类	√

可见，public具有最大权限。private则是最小权限。编写代码时，如果没有特殊的考虑，建议这样使用权限：
①成员变量使用private，隐藏细节
②构造方法使用public，方便创建对象
③成员方法使用public，方便调用方法

如果不加权限修饰符，其访问能力与default修饰符相同

7. 单例设计模式

单例设计模式是解决某类问题行之有效的方法，是一种思想，是规律的总结。用来保证某个类在内存中只有一个对象。
保证唯一性的思想及步骤：
①为了避免其他程序建立该类对象，先禁止其他程序建立该类对象，即先将构造方法私有化
②为了方便其他程序访问到该类对象，须在本类中创建一个该类私有对象
③为了方便其他程序访问到该类对象，可对外提供一个公共访问方式
比如API中的Runtime类就是单例设计模式。

public class Runtime {
    private static Runtime currentRuntime = new Runtime();
    public static Runtime getRuntime() {
        return currentRuntime;
    }
}

饿汉式和懒汉式
区别：
①饿汉式是类一加载进内存就创建好了对象；懒汉式则是类加载进内存的时候，对象还没有存在，只有调用了getInstance()方法时，对象才开始创建。
②懒汉式是延迟加载，如果多个线程同时操作懒汉式时就有可能出现线程安全问题，解决线程安全问题，可以加同步synchronized来解决。但是加了同步之后，每一次都要比较锁，效率就变慢了，所以可以加双重判断来提高程序效率。

注：开发常用饿汉式，因为饿汉式简单安全。懒汉式多线程的时候容易发生问题

饿汉式：当类加载的时候，就创建对象。

class Student {
    private Student(){} //将构造方法私有化
    private static final Student s = new Student(); //在本类中创建一个私有对象
    public static Student getInstance() { //向外提供一个公共的访问方法
        return s;
    }
}

懒汉式：当使用的时候，才去创建对象。

class Student {
    private Student(){}
    private static Student stu = null;
    public static Student getInstance() {
        if(s == null) {
            stu = new Student();
        }
        return s;
    }
}