面向对象

最新推荐文章于 2020-09-04 11:28:29 发布

原创最新推荐文章于 2020-09-04 11:28:29 发布 · 305 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍了面向对象编程的基本概念，包括封装、继承、多态等核心特性，并探讨了类与对象的关系，以及如何利用这些特性来设计更加灵活和可扩展的软件。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

面向对象：

特点：

基于过程

1：将复杂的事情简单化。

2：面向对象将以前的过程中的执行者，变成了指挥者。

3：面向对象这种思想是符合现在人们思考习惯的一种思想。

过程其实就是函数

对象是将函数等一些内容进行了封装

面向对象的特征：

封装，继承，多态

在类中定义其实都称之为成员。成员有两种：

1：成员变量：其实对应的就是事物的属性。

2：成员函数：其实对应的就是事物的行为。

所以，其实定义类，就是在定义成员变量和成员函数。但是在定义前，必须先要对事物进行属性和行为的分析，才可以用代码来体现。

成员变量和局部变量：

作用范围。

成员变量作用于整个类中.

局部变量作用与函数（方法），或者语句中。

在内存的位置：

成员变量：在堆内存中，因为对象的存在，才在内存中存在

局部变量：存在栈内存中

匿名对象使用场景：

1：当对方法只进行一次调用的时候，可以使用匿名对象。

2：当对象对成员进行多次调用时，不能使用匿名对象。必须给对象起名字。

封装（面向对象特征之一）：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：将变化隔离；便于使用；提高重用性；安全性。

封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。

private 私有只是它的其中一种表现形式

main 主函数固定格式，jvm识别

static 静态（修饰成员变量和成员函数）

用法：类名.静态方式。

静态随着类的加载而加载。而且优先于对象存在。

静态方法只能访问静态成员，不能使用this,super

什么时候使用静态：

要从两方面入手：

因为静态修饰的内容有成员变量和函数

什么时候定义静态变量（类变量）呢？

当对象中出现共享数据时，该数据被静态所修饰

对象中的特有数据要定义成非晶态存在于堆内存中

什么时候定义静态函数

当功能内部没有访问到非静态数据（对象的特有数据）

那么该功能可以定义成静态的

静态代码化：

static

{

静态代码块中的执行语句。

}

特点：随着类的加载而执行，只执行一次

用于给类进行初始化的

静态代码块、构造代码块、构造函数同时存在时的执行顺序：静态代码块 à 构造代码块 à 构造函数；

生成Java帮助文档：命令格式：javadoc –d 文件夹名 –auther –version *.java

/** //格式

*类描述

*@author 作者名

*@version 版本号

/**

*方法描述

*@param 参数描述

*@return 返回值描述

设计模式：

解决某一类问题最行之有效的方法

单例设计模型：

解决一个类在内存只存在一个对象。

如何保证对象唯一性呢？

思想：

1，不让其他程序创建该类对象。

2，在本类中创建一个本类对象。

3，对外提供方法，让其他程序获取这个对象。

步骤：

1.将构造函数私有化

2.在类中创建一个本类对象

3.提供一个方法可以获取该对象

对于事物该怎么描述，还怎么描述

当需要将该事物保证在内存中唯一时，就将以上三步加上

饿汉式（建议使用）

Single 一进内存，就已经创建好了对象

class Single{

private Single(){} //私有化构造函数。

private static Single s = new Single(); //创建私有并静态的本类对象。

public static Single getInstance(){ //定义公有并静态的方法，返回该对象。

return s;

}

例子：

class Student

{

private int age;

private static Student s=new Student();

private Student(){}

public static Student getStudent()

{

return s;

}

public void setAge(int age)

{

this.age=age;

}

public int getAge()

{

return age;

}

调用：在主函数

Student s=Student.getStudent();

s.setAge(20);

System.out.println(s.getAge());

---------------------------------------------

懒汉式:延迟加载方式。

class Single2{

private Single2(){}

private static Single2 s = null;

public static Single2 getInstance(){

if(s==null)

synchronized(Single2.class)

{ (锁)需要同步synchronized，否则内存错误

if(s==null) //如果不用前面两句，其他的对象，满足条件就会都进来

s = new Single2();

}

return s;

}

继承：

1.提高了代码的复用性

2.让类与类之间产生了关系。有了这个关系，才有了多态的特性

注意：必须是类与类之间有所属关系才可以继承

只支持单继承，因为多继承会带来安全隐患：当多个父类定义了相同功能，

当功能内容不同时，子类对象不确定要运行哪一个

java支持多层继承，也就是一个继承体系

简单说：对于一个继承体系的使用，查阅顶层父类中的内容，创建最底层子类的对象。

this 对本类引用

super 对父类引用

问题：super()和this()是否可以同时出现的构造函数中。

两个语句只能有一个定义在第一行，所以只能出现其中一个。

super()或者this():为什么一定要定义在第一行？

因为super()或者this()都是调用构造函数，构造函数用于初始化，所以初始化的动作要先完成。

final特点：

1：这个关键字是一个修饰符，可以修饰类，方法，变量。

2：被final修饰的类是一个最终类，不可以被继承。

3：被final修饰的方法是一个最终方法，不可以被覆盖。

4：被final修饰的变量是一个常量，只能赋值一次。

抽象类: abstract

抽象：不具体，看不明白。抽象类表象体现。

在不断抽取过程中，将共性内容中的方法声明抽取，但是方法不一样，没有抽取，这时抽取到的方法，并不具体，需要被指定关键字abstract所标示，声明为抽象方法。

抽象方法所在类一定要标示为抽象类，也就是说该类需要被abstract关键字所修饰。

抽象类的特点：

1：抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。

2：抽象方法只定义方法声明，并不定义方法实现。

3：抽象类不可以被创建对象(实例化)。

4：只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。

抽象类的细节：

1：抽象类中是否有构造函数？有，用于给子类对象进行初始化。

2：抽象类中是否可以定义非抽象方法？

可以。其实，抽象类和一般类没有太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。所以抽象类和一般类在定义上，都是需要定义属性和行为的。只不过，比一般类多了一个抽象函数。而且比一般类少了一个创建对象的部分。

3：抽象关键字abstract和哪些不可以共存？final ,private , static

4：抽象类中可不可以不定义抽象方法？可以。抽象方法目的仅仅为了不让该类创建对象。

模板方法设计模式：

解决的问题：当功能内部一部分实现时确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。

abstract class GetTime{

public final void getTime(){ //此功能如果不需要复写，可加final限定

long start = System.currentTimeMillis();

code(); //不确定的功能部分，提取出来，通过抽象方法实现

long end = System.currentTimeMillis();

System.out.println("毫秒是："+(end-start));

}

public abstract void code(); //抽象不确定的功能，让子类复写实现

}

class SubDemo extends GetTime{

public void code(){ //子类复写功能方法

for(int y=0; y<1000; y++){

System.out.println("y");

}

接口：

当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示

class 用于定义类

interface 用于定义接口 interface 类名

implements 接口

接口定义时，格式特点：

1.接口中常见定义：常量，抽象方法

2.接口中的成员都有固定修饰符

常量：public static final

方法：public abstract final

接口中的成员都是public

接口：

是不可以创建对象的，因为有抽象方法。

需要被子类实现，子类对接口的抽象方法全部覆盖后，子类才可以实例化

否则子类是一个抽象类

接口里的方法是public ，子类方法也要public

接口的特点：

1.接口直接有继承关系

2.接口是承训的功能扩展

3.接口是对外提供的规则

抽象类和接口的共性：都是不断向上抽取的结果。

抽象类和接口的区别：

1：抽象类只能被继承，而且只能单继承。

接口需要被实现，而且可以多实现。

2：抽象类中可以定义非抽象方法，子类可以直接继承使用。

接口中都有抽象方法，需要子类去实现。

3：抽象类使用的是 is a 关系。

接口使用的 like a 关系。

4：抽象类的成员修饰符可以自定义。

接口中的成员修饰符是固定的。全都是public的。

多态：

某种事物存在的多种形态

体现：父类引用或者接口的引用指向了自己的子类对象。//Animal a = new Cat();

多态的好处：提高了程序的扩展性。

多态的弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)

多态的前提：

1：必须要有关系，比如继承、或者实现。

2：通常会有覆盖操作。

如果想要调用猫的特有方法时：

强制讲父类的引用。转成子类类型。向下转型

Animal a=new Cat();

a.eat();

Cat c=(Cat) a;

c.catch();

instanceof

判断对象是否实现了指定的接口或继承了指定的类

Student instanceof Person = true;//student继承了person类

多态在子父类中的成员上的体现的特点：

1，成员变量：在多态中，子父类成员变量同名。

在编译时期：参考的是引用型变量所属的类中是否有调用的成员。（编译时不产生对象，只检查语法错误）

运行时期：也是参考引用型变量所属的类中是否有调用的成员。

简单一句话：无论编译和运行，成员变量参考的都是引用变量所属的类中的成员变量。

再说的更容易记忆一些：成员变量 --- 编译运行都看 = 左边。

2，成员函数。

编译时期：参考引用型变量所属的类中是否有调用的方法。

运行事情：参考的是对象所属的类中是否有调用的方法。

为什么是这样的呢？因为在子父类中，对于一模一样的成员函数，有一个特性：覆盖。

简单一句：成员函数，编译看引用型变量所属的类，运行看对象所属的类。

更简单：成员函数 --- 编译看 = 左边，运行看 = 右边。

3，静态函数。

编译时期：参考的是引用型变量所属的类中是否有调用的成员。

运行时期：也是参考引用型变量所属的类中是否有调用的成员。

为什么是这样的呢？因为静态方法，其实不所属于对象，而是所属于该方法所在的类。

调用静态的方法引用是哪个类的引用调用的就是哪个类中的静态方法。

简单说：静态函数 --- 编译运行都看 = 左边。