JavaSE--面向对象

JavaSE – 面向对象

一、面向对象概述

1.1 面向对象和面向过程

​ 面向过程：面向过程其实就是面向具体的每一个步骤和过程，也就是面对具体的每一个功能函数，这些功能函数相互调用，完成需求。即就是朝着要实现的功能，一步步的去操作。

​ 面向过程：面向对象是基于面向过程，对象是将功能进行了封装。只要找到了具体的类，创建出对象，就可以调用其中的具体功能。面向对象也是用来解决问题的一种思维模式。即就是朝着要实现功能的目标，有该功能就调用类。没有的话，就自己设计类。

1.2 面向对象和面向过程差异(面向对象的好处)

1. 面向对象是一种更符合人们思考习惯的思想
2. 面向过程中更多的体现的是执行者，面向对象中更多的体现是指挥者。指挥对象做事情。
3. 面向对象将复杂的问题简单化。

1.3 面向对象程序设计

案例:把大象装进冰箱

针对具体的需求，可以使用名词提炼法进行分析，寻找具体的对象。

• 要求：把大象装冰箱里
• 对象：大象、冰箱

实施的步骤：

1. 打开冰箱门。
2. 将大象装进去。
3. 关闭冰箱门。

以上步骤有个问题就是：这些行为的发起者是谁？？？谁来完成？？？

分析发现打开、装、关闭都是冰箱的功能。即冰箱对象具备如下功能：

• 冰箱打开。
• 冰箱存储。
• 冰箱关闭。

用伪代码描述，上述需求中有两个具体的事物 大象 和 冰箱 。

public class 大象{}// 大象类
public class 冰箱{// 冰箱类
    打开(){};
    存储(大象){};
   	关闭(){};
}

当把具体的事物描述清楚之后，需要使用这些具体的事物，Java使用具体的事物，需要通过new关键字来创建这个事物的具体实例。

// 创建冰箱对象
冰箱 bx = new 冰箱(); 
// 调用冰箱的功能
对象.功能()；
bx.打开();
bx.存储(new 大象());
bx.关闭();

总结:

1. 先按照名词提炼问题领域中的对象。
2. 对对象进行描述，其实就是在明确对象中应该具备的属性和功能。
3. 通过 new关键字 就可以创建该事物的具体对象。
4. 通过该对象调用它以后的功能。使用 . 访问属性和调用方法() 如: 大象.鼻子

二、类和对象

2.1 类与对象的概念

​ 类：现实生活中一种事物的抽象，把对事物的描述做成数据也就是属性，把事物具备的功能做成方法。

​ 对象：对象（object)代表现实世界中可以明确标识的一个实体。例如：一名学生、一张桌子、一个圆、一个按钮甚至一笔贷款都可以当做是一个对象。每个对象都有自己独特的标识、状态和行为。

2.2 类与对象的区别

类是用于描述现实事物的，它将现实事物进行抽象化，模板化描述。将事物的特点（属性）和行为封装在其中。比如小汽车的图纸，图纸就是小汽车的模版。图纸上画着小汽车的各种特点和功能要求。

对象是现实生活中存在的具体的实例、个体。即生活中看到每一个事物，以及我们想象中的事物抽象的概念，都是某一类事物的实例和个体。而这些个体都属于某一类事物，即这些个体都是某一类事物中的具体的实例。比如，小汽车就是一类事物，而小汽车又是基于小汽车图纸制造出来的真实个体。因此我们生活中的每一个实物都可以理解为是某一类事物的中的一个个体。创建对象通过对象就可以调用具体的属性和行为。

创建对象：new + 构造方法()

构造方法：无返回值，名字与类名相同，功能是配合new关键字来创建对象。

注意：构造方法无返回值因为不需要额外信息数据。与类名一致是因为创建同名对象。

构造方法根据属性的不同有多种重载形式，通常把无参数的构造方法称为无参构造

对象的内存：new + 构造方法() 创建的对象，在堆内存中开辟空间，属性有默认值

2.3 成员变量和局部变量的区别

1. 在内存中的位置不同：

   成员变量：成员变量存储在堆内存的对象中

   局部变量：局部变量存储在栈内存的方法中

2. 定义的位置不同：

   成员变量：定义在类中

   局部变量：定义在方法中

3. 生命周期不同：

   成员变量：成员变量随着对象的创建而创建，消失而消失

   局部变量：局部变量压栈出现，弹栈消失

2.4 匿名对象

​ 当我们的对象只是为了调用某个方法或者作为参数时，使用匿名对象，其实就是不给创建的对象以引用。

class Car
{
	String color;// 颜色
	int number;// 轮胎数
	//描述行为，即方法
	void run()
	{
		System.out.println(color + ":" + number);
	}
}

class CarDemo
{
    public static void main(String[] args)
	{
         //创建Car.class类的对象。
		 Car c = new Car();
         //调用run方法
         c.run();
         //创建Car.class类的对象。
         Car c2 = new Car();
        //调用run方法
         c2.run();
     }
}

匿名对象的使用场景：当对象对方法进行调用时，而且只调用一次时，可以简化成匿名对象来书写

Car c = new Car();// 创建对象Car
c.run();// 调用run()方法

// 使用匿名对象并调用run()方法
new Car().run();

匿名对象也可以作为参数传递：

class CarDemo
{
    public static void main(String[] args)
	{    
        Car c = new Car();// 创建Car对象
        show(c);    //简化成 show(new Car());//把匿名对象作为实际参数进行传递。
    }
    public static void show(Car cc)  // Car cc = c;  Car cc = new Car();
	{
		cc.color = "red";
		cc.number = 4;
		cc.run();
	}
}

三、封装

封装：是指隐藏对象的属性和实现的细节，仅对外提供公共访问方式。在类定义中用private关键字来实现封装。

封装的特点：

1. 隐藏了实现细节
2. 提高了代码的复用性
3. 提高安全性

private关键字：访问修饰符，代表私有的属性和方法，只能自己访问，对外访问不到

对外访问：private修饰的属性访问不到，就需要提供getXxx()方法和setXxx()方法，即就是对外设置或者获取属性的方法.

构造方法：没有返回值，方法名和类名一致，用来完成初始化，不需要返回值

​ 构造方法不需要私有化，否则无法进行对象的创建.

例如：

public class Demo{
  private String name;// 姓名
  // 空构造
  public Demo(){
    
  }
  // 全构造
  public Demo(String name){
    this.name = name;
  }
}

构造方法和一般方法的区别：

1. 构造方法只执行一次，一般方法可以多次执行
2. 构造方法在初始化时使用，一般方法针对自己需求使用（当需要时进行调用即可使用）

this关键字：代表当前对象，当抽象属性和参数同名时，用this代表当前对象

this调用当前属性：this.属性;

this调用当前方法：this.方法(参数列表);

this调用构造方法：this(参数列表);

构造函数之间的调用可以通过this关键字来完成。

class Person 
{
	// Person的成员属性
	private int age;
	private String name;
	//无参数的构造函数
	Person()
	{
	}
	//给姓名初始化的构造函数
	Person(String nm)
	{
		name = nm;
	}
	//给姓名和年龄初始化的构造函数
	Person(String nm , int a)
	{
		//由于已经存在给姓名进行初始化的构造函数 name = nm;因此只需要调用即可
		//调用其他构造函数，需要通过this关键字来调用
		this(nm);
		//给年龄初始化
		age = a;
	}
}

构造函数之间的相互调用可以通过this关键字完成。

构造函数调用格式：

this(参数列表);

方法的自调用

this.XXX(参数列表)

super关键字：父类类的引用

四、static

static 静态的，代表的是类级别的属性和方法，是把非私有的属性进行共享使用

static修饰的方法：直接使用类名.方法()**调用，不需要对象，但是不能调用费静态方法，因为非静态方法的对象还没创建出来.

static修饰的属性：是类级别的全对象共享，只要有一个对象对其进行操作其他对象单位该静态属性也会随之发生变化

静态方法使用注意事项：

1. 静态方法不能访问非静态的成员。但是非静态可以访问静态成员的。

   说明：静态的弊端在于访问出现局限性。好处是可以直接被类名调用。

2. 静态方法中不允许出现this，super关键字。

   静态不仅可以修饰方法，同时静态也可以修饰成员变量。

class Circle
{
	//圆的半径
	private double radius = 10;
	//圆周率，由于圆周率是固定值，因此所有对象共享这个数据
	//没有必要每个对象中拥有这个数据，因此可以使用静态修饰
	static double pi = 3.14;
	//带参数的构造函数
	Circle(double radius)
	{
		this.radius = radius;
	}
	//获取圆面积
	double getArea()
	{
		return radius * radius * pi;
	}
}
class CircleDemo 
{
	public static void main(String[] args) 
	{
		System.out.println(new Circle(3).getArea());
	}
}

如果pi这个变量没有被静态修饰的话，当创建Circle对象时，每个对象中都会有pi这个变量，但是pi是个固定不变的值，没有必要每个对象中拥有，这时可以将这个变量静态修饰，让所有对象共享就可以了。

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

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

1. 变量所属不同

   静态变量所属于类，也称为类变量。

   成员变量所属于对象，也称为实例变量(对象变量)。

2. 内存中的位置

   静态变量存储于方法区中的静态区中。

   成员变量存储于堆内存中。

3. 在内存中出现的时间

   静态变量随着类的加载而加载，随着类的消失而消失。

   成员变量随着对象的创建而在堆内存中出现，随着对象的消失而消失。

五、继承

继承：使用关键字extends，让一个类能够访问到一个类的非private属性和方法，提高被继承类的代码复用性。

同名属性：优先使用自己定义的，在自己的方法中通常有缺省的this来明确调用的是谁的属性，可以使用super关键字来代表父类进一步访问到父类的属性。

同名方法：发生了方法的重写

继承的好处:

1. 提高了代码的复用性，提高软件开发效率
2. 让类与类之间有了关系，提供多态的前提

Java中只支持单继承，不支持多继承

但是Java支持多层继承(继承体系)

class A{}
class B extends A{}
class C extends B{}

final关键字：意为最终，不可变的。可以修饰类，类的成员，以及局部变量

final修饰类：不可继承

final修饰方法：不可重写

final修饰变量：称为常量，有初始值不可以被修改

final修饰的引用变量：引用不能改，引用的对象的值可以修改