Java基础知识回顾1-面向对象

一、Java特性

1.面向对象

众所周知，Java是一个面向对象的语言，万物皆对象。

面向对象基本思想是使用对象、类、继承、封装、多态等基本概念来进行程序设计。从现实世界中客观存在的事物(即对象)出发来构造软件系统，并且在系统构造中尽可能运用人类的自然思维方式。程序就是由无数个对象和对象的行为组装而成，当程序请求某个对象时，实际上就是通过一个请求，将您的对象传递给程序的其他操作，再将一个新的对象返回给你。

2.分布式

分布式系统对于用户而言，他们面对的就是一个服务器，提供用户需要的服务而已，实际上这些服务是通过背后的众多服务器组成的一个分布式系统。

3.健壮性

Web的多平台环境对程序有特别的要求，因为程序必须在各种系统中可靠地运行。为了获得可靠性，Java在一些关键领域进行了限制，从而迫使程序员在程序开发中及早地发现错误。同时程序员不必担心会引起编程错误的许多常见的问题，因为Java是强类型的语言，它在编译时会检查代码。

4.安全性

垃圾回收机制:不需要程序员直接控制内存回收，由垃圾回收器在后台自动回收不再使用的内存，避免程序忘记及时回收内存，导致内存泄漏。

异常处理机制:Java异常机制主要依赖于try、catch、finally、throw、throws五个关键字。

强类型转换:只有在满足强制转换规则的情况下才能强转成功。

5.体系结构中立

编译器生成一个体系结构中立的目标文件格式，这是一种编译过的代码，只要有Java运行时系统就可以在许多处理器上运行。Java编译器通过生成与特定的计算机体系结构无关的字节码来实现这一特性。

6.可移植性

所谓的可移植性指的是同一个程序可以在不同的操作系统之间任意进行部署，这样就减少了开发的难度，在Java里面如果要实现可移植性的控制，那么主要依赖JVM(java虚拟机)。

7.解释性

有人说Java是编译型的。因为所有的Java代码都是要编译的，java不经过编译就无法执行。 也有人说Java是解释型的。因为java代码编译后不能直接运行，它是解释运行在JVM上的，所以它是解释型的。

8.高性能

即时编译器可以监控经常执行的代码并优化这些代码以提高速度。

9.多线程

指的是这个程序运行时产生了不止一个线程。

10.动态性

Java本质为静态语言，而不是动态语言。动态语言显著的特点是在程序运行时，可以改变程序结构或变量类型，典型的动态语言有Python、ruby、javascript等。Java不是动态语言，但Java具有一定的动态性，表现在以下几个方面：

1. 反射机制；
2. 动态字节码操作；
3. 动态编译；
4. 执行其他脚本代码；

二、对象

对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。一个对象由一组属性和对这组属性进行操作的一组服务组成。

类的实例化可生成对象，一个对象的生命周期包括三个阶段：生成、使用、消除。

当不存在对一个对象的引用时，该对象成为一个无用对象。Java的垃圾收集器自动扫描对象的动态内存区，把没有引用的对象作为垃圾收集起来并释放。当系统内存用尽或调用System.gc( )要求垃圾回收时，垃圾回收线程与系统同步运行。

三、类

类是具有相同属性和方法的一组对象的集合，它为属于该类的所有对象统一的抽象描述，其内部包含属性和方法两个主要部分。

1.类声明

[public][abstract|final] class className [extends superclassName] [implements interfaceNameList]{……}

其中，修饰符public,abstract,final 说明了类的属性，className为类名，superclassName为类的父类的名字，interfaceNameList为类所实现的接口列表。

2.类体

class className{
    [public | protected | private ] [static] [final] [transient] [volatile] type variableName;//成员变量
    [public | protected | private ] [static] [final | abstract] [native] [synchronized] returnType methodName([paramList]) [throws exceptionList]{
        statements
    }//成员方法
}

成员变量关键词含义:

static:静态变量

final:常量

transient:暂时性变量，用于对象的串行化

volatile:用于并发线程的共享

方法中的关键词含义:

static:类方法，可以直接通过类名调用

final:方法不能被重写

abstract:抽象方法，没有方法体

native:集成其他语言的代码

synchronized:控制多个并发线程访问

3.方法体

方法体是对方法的实现，它包括局部变量的声明以及所有合法的Java指令。

4.构造方法

构造方法是一个特殊的方法。Java中的每个类都有构造方法，用来初始化该类的一个对象。

构造方法具有和类名相同的名称，而且不返回任何数据类型。

重载经常用于构造方法。

构造方法只能由new运算符调用。

四、面向对象的基本特性

1.封装

封装就是尽可能的隐藏对象内部细节，只保留有限的接口和方法与外界进行交互。封装的原则是使对象以外的部分不能随意的访问和操作对象的内部属性，从而避免了外键对对象内部属性的破坏。

(1).可以通过对类的成员设置一定的访问权限，实现类中成员的信息隐藏。

private:类中限定为private的成员，只能被这个类本身访问;

default:类中不加任何访问修饰符属于缺省的(default)访问状态，可以被这个类本身和同一个包中的类所访问;

protected:可以被这个类本身、它的子类(包括同一个包中以及不同包中的子类）和同一个包中所有其他类访问;

public:可以被所有类访问;

(2).封装的优点:

1.良好的封装能够减少耦合

2.类内部的结构可以自由修改

3.可以对成员变量进行更精确的控制

4.隐藏信息，实现细节

(3).示例代码:

package day01;

/**
 * @author qx
 * @date 2023/10/19
 * @des 用户实体类
 */
public class User {

    private Long id;
    private String name;
    private Integer age;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

属性都是用private进行修饰，只能本类才能访问。public修饰方法提供外界访问。

2.继承

子类的对象拥有父类的全部属性和方法，称作子类对父类的继承。

Java中父类可以拥有多个子类，但是子类只能继承一个父类，称为单继承;

继承实现了代码的复用;

Java中的所有类都是通过直接或间接地继承java.lang.Object类得到的;

子类不能继承父类中访问权限为private的成员变量和方法;

子类可以重写父类的方法，即命名与父类同名的方法;

package day02;

/**
 * @author qx
 * @date 2023/10/19
 * @des 继承Student
 */
public class StudentChild extends Student {

    public void show() {
        super.setName("hello");
        System.out.println(super.getName());
    }
}

3.多态

对象的多态性是指在父类中定义的属性或方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或方法在父类及其各个子类中具有不同的语义。

1. 编译时多态：在编译阶段，具体调用哪个被重载的方法，编译器会根据参数的不同来静态确定调用相应的方法；
2. 运行时多态：由于子类继承了父类所有的属性（私有的除外），所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方，都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用子类的方法。

package day02;

/**
 * @author qx
 * @date 2023/10/11
 * @des
 */
public class Student {

    public  Long id;
    public String name;

    public Student() {
    }

    public Student(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void show(){
        System.out.println("student");
    }
}

package day02;

/**
 * @author qx
 * @date 2023/10/19
 * @des 继承Student
 */
public class StudentChild1 extends Student {

    @Override
    public void show() {
        System.out.println("studentChild1");
    }
}

package day02;

/**
 * @author qx
 * @date 2023/10/19
 * @des 继承Student
 */
public class StudentChild2 extends Student {

    @Override
    public void show() {
        System.out.println("studentChild2");
    }
}

package day02;

/**
 * @author qx
 * @date 2023/10/19
 * @des
 */
public class StudentTest {
    public static void main(String[] args) {
        Student s1 = new StudentChild1();
        Student s2 = new StudentChild2();

        // 分别调用各自的show方法
        s1.show();
        s2.show();
        // 输出
        //studentChild1
		//studentChild2
    }
}

4.重载

方法重载是让类以统一的方式处理不同数据类型的手段。

一个类中可以创建多个方法，他们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给他们的不同参数个数和参数类型来决定具体使用哪个方法。

返回值类型可以相同也可以不相同，无法以返回类型作为重载函数的区分标准。

public void show(){
        System.out.println("student");
    }
    public void show(String name){
        System.out.println(name);
    }

5.重写

子类对父类的方法进行重新编写。如果子类中的方法和父类有相同的方法名、返回类型和参数、我们说该方法被重写。

如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。

子类函数的访问修饰权限不能低于父类的。

package day02;

/**
 * @author qx
 * @date 2023/10/11
 * @des
 */
public class Student {

    public Long id;
    public String name;

    public Student() {
    }

    public Student(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void show() {
        System.out.println("student");
    }
}

子类重写show方法

package day02;

/**
 * @author qx
 * @date 2023/10/19
 * @des 继承Student
 */
public class StudentChild1 extends Student {

    @Override
    public void show() {
        System.out.println("studentChild1");
    }
}

五、对象间的四种关系

1.依赖

依赖关系表示一个类依赖于另一个类的定义。例如，一个人(Person)可以买车(car)和房子(House)，Person类依赖于Car类和House类的定义，因为Person类引用了Car和House。

2.关联

关联关系是类与类的连接，它使一个类知道另一个类的属性和方法。关联可以是双向的，也可以是单向的。在Java语言中，关联关系一般使用成员变量来实现。

3.聚合

聚合(Aggregation) 关系是关联关系的一种，是强的关联关系。聚合是整体和个体之间的关系。与关联关系一样，聚合关系也是通过实例变量实现的。但是关联关系所涉及的两个类是处在同一层次上的，而在聚合关系中，两个类是处在不平等层次上的，一个代表整体，另一个代表部分。

4.组合

组合(Composition) 关系是关联关系的一种，是比聚合关系强的关系。它要求普通的聚合关系中代表整体的对象负责代表部分对象的生命周期，组合关系是不能共享的。