类与对象
1. 面向对象与面向过程
什么是面向过程
概述：自顶而下的编程模式
把问题分解成一个一个步骤，每个步骤用函数实现，依次调用即可
就是说，在进行面向过程编程的时候，不需要考虑那么多
上来先定义一个函数，然后使用各种诸如if-else、for-each等方式进行代码执行
最典型的用法就是实现一个简单的算法，比如实现冒泡排序
什么是面向对象
概述：将事务高度抽象化的编程模式
将问题分解成一个一个步骤，对每个步骤进行相应的抽象，形成对象
通过不同对象之间的调用，组合解决问题
也就是说，在进行面向对象进行编程的时候，要把属性、行为等封装成对象，然后基于这些对象及对象的能力进行业务逻辑的实现
比如：想要造一辆车，上来要先把车的各种属性定义出来，然后抽象成一个Car类
面向对象的五大基本原则
五大基本原则：
单一职责原则（Single-Responsibility Principle）
开放封闭原则（Open-Closed principle）
里氏替换替换原则（Liskov-Substituion Principle）
依赖倒置原则（Dependency-Inversion Principle）
接口隔离原则（Interface-Segregation Principle）
区别
- 面向过程：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源
所以当性能是最重要的考量因素时，比如单片机，嵌入式开发，Linux/Unix等一般采用面向过程开发
但是面向过程没有面向对象易维护，易复用，易扩展 - 面向对象：易维护，易复用，易扩展；因为面向对象有封装，继承，多态性的特性
所以可以设计出低耦合的系统，使系统更加灵活，更加易于维护
但是面向对象性能比面向过程低
2. 类与对象的概念
1.什么是类
- 类：指的是对客观事物的一种描述，是对现实中一类具有共同属性和行为的事物的抽象。
2.什么是对象
- 对象：指的是具体存在的事物，是能够看得到摸的着的真实存在的实体。
3.成员变量
成员变量（Member Variable）也称为实例变量（Instance Variable），是定义在类中的变量。它们属于类的每个对象实例，并且可以被类中的所有成员方法访问和使用。
下面是一个简单的例子，演示了一个名为Person的类和其中的成员变量：
public class Person {
private String name;
private int age;
// 构造方法
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 成员方法：打印个人信息
public void printInfo() {
System.out.println("姓名：" + name);
System.out.println("年龄：" + age);
}
}
在这个例子中，Person类有两个私有的成员变量name和age。这些成员变量存储了每个Person对象的姓名和年龄信息。
成员变量在类中声明，在类的任何方法（如构造方法、成员方法等）之外。它们具有类范围的作用域，意味着它们可被同一类中的所有方法访问和使用。
4.成员方法
成员方法（Member Method）也称为实例方法（Instance Method），是定义在类中的操作或行为。它们用于访问和操作对象的属性，并执行特定的任务。每个对象都可以调用其所属类的成员方法。
下面是一个简单的例子，演示了一个名为Person的类和其中的成员方法：
public class Person {
private String name;
private int age;
// 构造方法
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 成员方法：获取姓名
public String getName() {
return name;
}
// 成员方法：获取年龄
public int getAge() {
return age;
}
// 成员方法：打印个人信息
public void printInfo() {
System.out.println("姓名：" + name);
System.out.println("年龄：" + age);
}
}
在这个例子中，Person类包含了两个私有属性name和age，以及构造方法和三个成员方法：getName、getAge和printInfo。getName和getAge方法用于获取对象的姓名和年龄属性值，而printInfo方法用于打印对象的姓名和年龄信息。
5.对象的实例化
一.对象实例化常用方式
方式一：直接new一个对象，最常用的一种。
方式二：反射，通过Class.forName("类的全限定名")。
方式三：构造器，通过Class.forName("类的全限定名")，再获取构造方法。
方式四：序列化，通过java.io.ObjectInputStream对象流的方式。
备注：工厂模式实例化、克隆实例化两种比较少用。
1.new一个对象
声名一个对象
public class NewObject {
/** 测试方法 */
public void print() {
System.out.println("NewObject print-------");
}
}
实例化
NewObject newObject = new NewObject();
newObject.print();
2.反射
声明一个对象
public class NewObject {
/** 测试方法 */
public void print() {
System.out.println("NewObject print-------");
}
}
实例化
Class<?> cla = Class.forName("com.oysept.instance.NewObject"); // 包名+类名
NewObject newObject = (NewObject) cla.newInstance(); // 实例化
newObject.print(); // 调用测试方法
3.构造器
声明一个对象
public class NewObject {
public NewObject() {
System.out.println("构造器1-------");
}
public NewObject(Object str) {
System.out.println("构造器2-------");
}
public NewObject(String str, Integer s) {
System.out.println("构造器3-------");
}
/** 测试方法 */
public void print() {
System.out.println("NewObject print-------");
}
}
场景一：无参构造方法
Class<?> cla = Class.forName("com.oysept.instance.NewObject"); // 包名+类名
// 场景一: 无参构造方法
Constructor<?> constructor = cla.getConstructor(); // 构造器
NewObject newObject = (NewObject) constructor.newInstance(); // 获取无参构造方法实例
newObject.print(); // 调用测试方法
场景二：带Object参数的构造方法
Class<?> cla = Class.forName("com.oysept.instance.NewObject"); // 包名+类名
// 场景二: 带Object参数的构造方法
Constructor<?> constructor = cla.getConstructor(Object.class);
NewObject newObject = (NewObject) constructor.newInstance("Object");
newObject.print(); // 调用测试方法
场景三: 带String和Integer参数的构造方法
Class<?> cla = Class.forName("com.oysept.instance.NewObject"); // 包名+类名
// 场景三: 带String和Integer参数的构造方法
Constructor<?> constructor = cla.getConstructor(String.class, Integer.class);
NewObject newObject = (NewObject) constructor.newInstance("String", 0);
newObject.print(); // 调用测试方法
4.序列化
声明一个对象，必须继承java.io.Serializable接口，才能序列化
import java.io.Serializable;
public class NewObject implements Serializable {
/**
* */
private static final long serialVersionUID = 1L;
/** 测试方法 */
public void print() {
System.out.println("NewObject print-------");
}
}
序列化方法
/** 序列化 */
public static void serializable(Object obj, String file) {
ObjectOutputStream objectOutputStream = null;
try {
objectOutputStream = new ObjectOutputStream(new FileOutputStream(new File(file)));
objectOutputStream.writeObject(new NewObject());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (objectOutputStream != null) {
objectOutputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
反序列化方法
/** 反序列化 */
public static Object unSerializable(String file) {
Object obj = null;
ObjectInputStream objectInputStream = null;
try {
objectInputStream = new ObjectInputStream(new FileInputStream(new File(file)));
obj = objectInputStream.readObject();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
try {
if (objectInputStream != null) {
objectInputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
return obj;
}
序列化实例测试
public static void main(String[] args) {
try {
String file = "D:\\object.object"; // 对象存放地址
// 先序列化
serializable(new NewObject(), file);
// 再反序列化
NewObject new4 = (NewObject) unSerializable(file);
new4.print(); // 调用测试方法
} catch (Exception e) {
e.printStackTrace();
}
}
6.对象的使用
对象被创建之后，就可以使用该对象。通过运算符“.”，对象可以实现对自己变量的访问和方法的调用。
对象对自己变量访问的语法格式如下：
对象名.变量名;
对象对自己方法调用的语法格式如下：
对象名.方法名([参数值列表]);
【例1】对象的创建与使用
package graph;
public class Application1 {
public static void main(String[] args) {
Rectangle rectangle1; //对象声明
rectangle1=new Rectangle(4.5,2.0);//对象实例化
double length=rectangle1.length; //访问对象的变量length
double width=rectangle1.width; //访问对象的变量width
double area=rectangle1.getArea(); //调用对象的方法getArea
System.out.println("length="+length+",width="+width+",area="+area);
}
}
在Java中，null表示应用没有指向任何对象，运行过程中系统如果发现使用了这样一个引用时，会产生程序运行异常。例如，下面程序在运行时由于的rectangle1值为null而引发一NullPointerException异常。
package graph;
public class Application1 {
static Rectangle rectangle1;
public static void main(String[] args) {
System.out.println(rectangle1.length);
}
}
7.对象的销毁
对象使用完之后需要对其进行清除。对象的清除是指释放对象占用的内存。在创建对象时，用户必须使用 new 操作符为对象分配内存。不过，在清除对象时，由系统自动进行内存回收，不需要用户额外处理。
Java 语言的内存自动回收称为垃圾回收（Garbage Collection）机制，简称 GC。垃圾回收机制是指 JVM 用于释放那些不再使用的对象所占用的内存。
Java 语言并不要求 JVM 有 GC，也没有规定 GC 如何工作。不过常用的 JVM 都有 GC，而且大多数 GC 都使用类似的算法管理内存和执行回收操作。
一个对象被当作垃圾回收的情况主要如下两种。
1）对象的引用超过其作用范围。
{
Object o = new Object(); // 对象o的作用范围，超过这个范围对象将被视为垃圾
}
1
2
3
2）对象被赋值为 null。
{
Object o = new Object();
o = null; // 对象被赋值为null将被视为垃圾
}
1
2
3
4
在 Java 的 Object 类中还提供了一个 protected 类型的 finalize() 方法，因此任何 Java 类都可以覆盖这个方法，在这个方法中进行释放对象所占有的相关资源的操作。
在 Java 虚拟机的堆区，每个对象都可能处于以下三种状态之一。
1 . 可触及状态：当一个对象被创建后，只要程序中还有引用变量引用它，那么它就始终处于可触及状态。
2 . 可复活状态：当程序不再有任何引用变量引用该对象时，该对象就进入可复活状态。在这个状态下，垃圾回收器会准备释放它所占用的内存，在释放之前，会调用它及其他处于可复活状态的对象的 finalize() 方法，这些 finalize() 方法有可能使该对象重新转到可触及状态。
3 . 不可触及状态：当 Java 虚拟机执行完所有可复活对象的 finalize() 方法后，如果这些方法都没有使该对象转到可触及状态，垃圾回收器才会真正回收它占用的内存。
8.匿名对象
匿名对象：没有名字的对象。
格式如下：
new Person().showMessage();
1
当然，你也可以通过Person创建一个实例对象后，再去调用Person类中的方法，具体如下：
Person p = new Person(); //创建对象p.
//给对象的各个属性赋值。
p.name = "蛋蛋";
p.age = 6;
p.height = 1.1;
//调用类中的方法
p.showMessage();
123456789
匿名对象的使用场景：
（1）类中的方法仅被对象调用一次。
new Person().showMessage(); //showMessage方法被对象调用一次的时候.
1
（2）匿名对象做实参传递。
Person.show(new Person()); //匿名对象做实际参数。
1
匿名对象与非匿名对象对属性赋值的区别：
首先，看下面的代码，你感觉两者之间的区别是什么？
//非匿名对象
Person p = new Person();
p.name = "蛋蛋";
p.age = 6;
p.height = 1.1;
//匿名对象
new Perosn.name = "花花";
new Perosn.age = 21;
new Perosn.height = 1.2;
1234567891011
两者的最大区别：非匿名对象只是给对象p的三个属性赋值；匿名对象在给三个匿名对象的不同属性（单个属性）赋值。
标签：name,对象,Person,NewObject,new,public From： https://www.cnblogs.com/zpjd/p/18336208