5面向对象编程

缺乏、安全感 2021-10-23 20:52 304阅读 0赞

5面向对象编程  
面向对象的三大特性

面向过程和面向对象  
面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。  
面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。  
例如五子棋，面向过程的设计思路就是首先分析问题的步骤：  
1、开始游戏，  
2、黑子先走，  
3、绘制画面，  
4、判断输赢，  
5、轮到白子，  
6、绘制画面，  
7、判断输赢，  
8、返回步骤2，  
9、输出最后结果。  
把上面每个步骤用分别的函数来实现，问题就解决了。  
而面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为：  
1、黑白双方，这两方的行为是一模一样的， 棋子 \{color // 子的颜色; 落子() \{\}\}  
2、棋盘系统，负责绘制画面， 棋盘系统 \{绘制画面() \{\}\}  
3、规则系统，负责判定诸如犯规、输赢等。 规则系统 \{判断输赢() \{\}\}  
第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。

以方法为单位组织代码、以类为单位组织代码。  
对象和类的概念  
对象：对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。  
类：类是一个模板，它描述一类对象的行为和状态。  
类：class  
对象：object、instance。某个类的对象，实际上就是某个类的实例。  
类可以看成一类对象的模板，对象可以看成该类的一个具体实例。  
类用于描述同一类型的对象的一个抽象的概念，类中定义了这一类对象所应具有的静态和动态的属性。  
对象是java程序的核心，在java程序中“万事万物皆对象”。  
jdk提供了很多类供编程人员使用，编程人员也可以定义自己的类。  
引用类型  
java语言中除了基本类型之外的变量类型都称之为引用类型。  
java中的对象是通过引用"reference"对其操作的。  
类的属性  
属性field，或者叫成员变量  
属性用于定义该类或该对象包含的数据或者说静态属性。  
属性作用范围是整个类体  
在定义成员变量时可以对其初始化，如果不对其初始化，java使用默认的值对其初始化。（数值：0，0.0, char:\\u0000, boolean:flase, 所有引用类型：null）  
属性定义格式：  
\[修饰符\] 属性类型 属性名 = \[默认值\]  
类的方法  
面向对象中，整个程序的基本单位是类，方法是从属于类的。  
方法定义格式：  
\[修饰符1 修饰符2 …\] 方法返回值类型 方法名(形参列表) \{  
// n条语句;  
\}  
形式参数：在方法被调用时用于接收外界输入的数据。  
实参：调用方法时实际传给方法的数据。  
返回值：方法在执行完毕后返还给调用它的环境的数据。  
返回值类型：事先约定的返回值的数据类型，如无返回值，必须给出返回值类型void。  
java语言中使用下述形式调用方法：对象名.方法名(实参列表)  
实参的数目、数据类型和次序必须和所调用方法声明的形参列表匹配。  
return 语句终止方法的运行并返回指定类型的数据。  
java中方法参数传递是：值传递！ https://www.cnblogs.com/nnngu/p/8299724.html  
变量的作用域

成员变量如果不赋初值，系统会给予其默认值。  
局部变量在使用前必须给其赋值，系统不会给其默认值。  
内存分析  
栈(自动分配连续的空间，后进先出)。存放：局部变量  
堆(不连续)。存放new出来的对象。  
方法区(属于堆的一部分)。存放：类的信息(代码)、static变量、常量池(字符串常量)等 。

垃圾回收机制  
对象空间的分配：使用new关键字创建对象即可  
对象空间的释放：将对象赋值null即可。垃圾回收器将负责回收所有“不可达”对象的内存空间。  
要点：  
程序员无权调用垃圾回收器。  
程序员可以通过System.gc()。通过GC运行，但是java规范并不能保证立即运行。  
finalize方法，是java提供给程序员用来释放对象或资源的方法，但是尽量少用。  
构造器（构造方法、构造函数）  
构造器，constructor  
构造器用于构造该类的实例。  
格式如下：  
\[修饰符\] 类名 (形参列表) \{  
// n条语句  
\}  
构造器是一种特殊的方法：  
通过new关键字调用  
构造器虽然有返回值，但是不能定义返回类型（返回值的类型肯定是本类），不能在构造器里调用return。  
如果我们没有定义构造器，系统会自动定义一个无参的构造器。如果已定义则默认无参的构造器不会存在。  
构造器的方法名必须和类名一致。  
方法的重载（overload）  
方法的重载是指一个类中可以定义有相同的名字，但参数不同的多个方法。调用时，会根据不同的参数列表选择对应的方法。  
口诀：二同三不同  
相同：同一个类，同一个方法名  
不同：参数列表不同（类型、个数、顺序不同）  
只有返回值不同不构成方法的重载  
只有形参的名称不同，不构成方法的重载  
与普通方法一样，构造方法也可以重载  
static  
在类中，用static声明的成员变量为静态成员变量，或者叫做类属性、类变量。  
它为该类的公共变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化。  
对于该类的所有对象来说，static成员变量只有一份。被该类的所有对象共享。  
可以使用“对象.类属性”来调用。不过，一般都是用“类名.类属性”调用。  
static变量置于方法区中。  
用static声明的方法为静态方法  
不需要对象就可以调用（类名.方法名）  
在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员。  
this  
普通方法中，this总是指向调用该方法的对象。  
构造方法中，this总是指向正要初始化的对象。  
this不能用于static方法。  
继承  
类是对对象的抽象，继承是对某一批类的抽象，从而实现对现实世界更好的建模。  
提高代码的复用性。  
extends的意思是“扩展”。子类是父类的扩展。  
java中只有单继承，没有像c++那样的多继承。多继承会引起混乱，使得继承链过于复杂，系统难于维护。多继承是为了实现代码的复用性，却引入了复杂性，使得系统类之间的关系混乱。  
java的多继承，可以通过接口来实现。  
如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object。  
不同的叫法：超类、父类、基类、子类、派生类。  
可以将父类作为一个属性，放入子类中（组合）  
方法的重写（override）  
在子类中可以根据需要对从基类中继承来的方法进行重写。  
重写方法必须和被重写方法具有相同方法名称、参数列表和返回值类型。  
重写方法不能使用比被重写方法更严的格访问权限。（由于多态）  
作业：自己写一个父类（车），再写里两个子类（自行车和小汽车）去继承父类，然后重写父类中的方法（两个以上）。  
Object类  
Object类是所有java类的基类  
如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类  
重写toString() 方法  
super  
super是直接父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性。  
普通方法没有顺序限制，可以随便调用。  
构造函数，任何类的构造函数中，若是构造函数的第一行代码没有显式的调用super(…)；那么java默认都会调用super();作为父类的初始化函数。所以这里的super();加不加都无所谓。  
final  
修饰变量：常量  
修饰方法：该方法不可被子类重写，但可以被重载  
修饰类：被final修饰的类不能有子类，不能被继承。比如：Math、String.  
封装  
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性和可维护性。  
程序设计追求“高内聚、低耦合”。  
高内聚就是类的内部数据操作细节自己完成，不允许外部干涉。  
低耦合就是仅暴露少量的方法给外部使用。  
访问控制修饰符  
Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。  
default (即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。  
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）  
public : 对所有类可见。使用对象：类、接口、变量、方法  
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。  
注意：default和protected的区别在视频一小时15分钟左右  
我们可以可以通过以下表来说明访问权限：

封装的要点：  
类的属性的处理：  
一般使用private（除非本属性确定会让子类继承）  
提供相应的get/set方法来访问相关属性，这些方法通常是public，从而提供对属性的读取操作。boolean类型的get方法默认名字是is开头。  
一般只用于本类的方法也使用private修饰。希望其他类调用的方法用public修饰。  
多态  
多态是同一个行为具有多个不同表现形式或形态的能力。  
现实中，比如我们按下 F1 键这个动作：  
如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；  
如果当前在 Word 下弹出的就是 Word 帮助；  
在 Windows 下弹出的就是 Windows 帮助和支持。  
同一个事件发生在不同的对象上会产生不同的结果。  
多态的优点：  
1. 消除类型之间的耦合关系  
2. 可替换性  
3. 可扩充性  
4. 接口性  
5. 灵活性  
6. 简化性  
多态的三个必要条件  
继承  
重写  
父类应用指向子类对象  
多态的实现方式  
方式一：重写  
这个内容已经在上一章节详细讲过，就不再阐述，详细可访问：Java 重写(Override)与重载(Overload)。  
方式二：接口  
1. 生活中的接口最具代表性的就是插座，例如一个三接头的插头都能接在三孔插座中，因为这个是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。  
2. java中的接口类似于生活中的接口，就是一些方法特征的集合，但没有方法的实现。具体可以看 java接口 这一章节的内容。  
方式三：抽象类和抽象方法  
instanceof运算符  
java 中的instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。  
抽象类  
抽象类是一个模板模式。抽象类为所有子类提供了一个通用模板，子类可以在这个模板基础上进行扩展。  
通过抽象类，可以避免子类设计的随意性。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。  
要点：  
有抽象方法的类只能定义为抽象类  
抽象类不能实例化，不能用new来实例化抽象类。  
抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，只能用来被子类调用。  
抽象类只能用来继承。  
抽象方法必须被子类实现。  
接口  
接口（英文：interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过实现接口的方式，从而来实现接口的抽象方法。  
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。  
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。  
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。  
接口的特性：  
1.接口可以多继承  
2.接口的方法声明必须是 public abstract 即便不写默认也是  
3.接口里面不能包含方法具体实现（jdk1.8之前）  
4.类继承接口必须实现接口里声明的全部方法，除非该类是抽象类  
5.接口里面可以声明 public static final 修饰的变量  
6.接口不能被实例化，但是可以被实现类创建  
内部类  
一般情况，我们把类定义成独立的单元。有一些情况下，我们把一个类放在另一个类的内部定义，成为内部类。  
内部类的作用：  
内部类提供了更好的封装。只能让外部类直接访问，不允许同一个包中的其他类直接访问。  
内部类可以直接访问外部类的私有属性，内部类被当成其它外部类的成员。但外部类不能访问内部类的内部属性。  
内部类的使用场合：  
由于内部类提供了更好的封装特性，并且可以很方便的访问外部类的属性。所以，通常内部类在只为所在外部类提供服务的情况下优先使用。  
内部类的分类  
静态内部类（内部类中最简单的形式）  
1、声明在类体中，方法体外，并且使用static修饰的内部类  
2、访问特点可以类比静态变量和静态方法  
3、脱离外部类的实例独立创建  
在外部类的外部创建内部类的实例  
new Outer.Inner();  
在外部类的内部创建内部类的实例  
new Inner();  
4、静态内部类体可以直接访问外部类中所有的静态成员，包括私有  
成员内部类（实例内部类）  
1、没有使用static修饰的内部类。  
2、在成员内部类中不允许出现静态变量和静态方法的声明。  
static只能用在静态常量的声明上  
3、成员内部类中可以访问外部类中所有的成员（变量、方法），包含私有成员，如果在内部类中定义有和外部类同名的实例变量，访问：  
Outer.this.outerMember;  
4、构建内部类的实例，要求必须外部类的实例先存在  
外部类的外部/外部类的静态方法：new Outer().new Inner();  
外部类的实例方法：  
new Inner();  
this.new Inner();  
局部内部类  
1、定义在方法体，甚至比方法体更小的代码块中  
2、类比局部变量  
3、局部内部类是所有内部类中使用最少的一种形式。  
4、局部内部类可以访问的外部类的成员根据所在方法体不同。  
如果在静态方法中：  
可以访问外部类中所有静态成员，包含私有  
如果在实例方法中：  
可以访问外部类中所有的成员，包含私有  
局部内部类可以访问所在方法中定义的局部变量，但是要求局部变量必须使用final修饰。  
匿名内部类  
1、没有名字的局部内部类。  
2、没有class、interface、implements、extends关键字  
3、没有构造器  
4、一般隐式的继承某一个父类或者实现某一个接口  
数组  
数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。  
Java 语言中提供的数组是用来存储固定大小的同类型元素。  
你可以声明一个数组变量，如 numbers\[100\] 来代替直接声明 100 个独立变量 number0，number1，…，number99。  
数组的声明  
dataType\[\] arrayRefVar; // 首先方法 dataType arrayRefVar\[\]; // 效果相同，但不是首选方法  
实例：  
int\[\] arrayInt; // 首先方法 int arrayInt\[\]; // 效果相同，但不是首选方法  
建议使用 dataType\[\] arrayRefVar 的声明风格声明数组变量。 dataType arrayRefVar\[\] 风格是来自 C/C++ 语言 ，在Java中采用是为了让 C/C++ 程序员能够快速理解java语言。  
创建数组：  
int\[\] arrayInt = new int\[4\];  
数组元素赋值：  
arrayInt\[0\] = 0;  
arrayInt\[1\] = 1;  
arrayInt\[2\] = 2;  
arrayInt\[3\] = 3;  
数组下标从0开始，到数组长度-1为止。  
直接赋值的方式：  
int\[\] arrayInt = \{0,1,2,3,4,5\};  
作业：快速排序、冒泡排序|希尔排序、归并排序  
int\[\] arr = \{23, 100, 40, 45, 45, 67, 32, 12, 5, 13, 53, 68\};  
数组的操作  
数组的拷贝  
System类中包含了一个arraycopy（public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);）方法，该方法可以将src数组里的元素值赋给dest数组的元素，其中srcpos指定从src数组的第几个元素开始赋值，length参数指定将src数组的多少个元素赋值给dest数组的元素。  
public class ArrayTest1 \{  
public static void main(String\[\] args) \{  
int\[\] arr = \{1, 2, 3, 4, 5, 6, 7\};  
int\[\] arr1 = \{8, 9, 10, 11, 12, 13\};

System.arraycopy(arr, 2, arr1, 2, 3);
        for (int i : arr1) {
            System.out.printf(i + "\t");
        }
    }

\}  
使用Arrays类  
打印数组：  
public class ArraysTest \{  
public static void main(String\[\] args) \{  
int\[\] arr = \{23, 100, 40, 45, 45, 67, 32, 12, 5, 13, 53, 68\};  
System.out.println(arr);  
System.out.println(Arrays.toString(arr));  
\}  
\}  
数组的排序  
public class ArraysTest \{  
public static void main(String\[\] args) \{  
int\[\] arr = \{23, 100, 40, 45, 45, 67, 32, 12, 5, 13, 53, 68\};  
System.out.println(arr);  
System.out.println(Arrays.toString(arr));

Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

\}  
输出结果：  
\[I@1922e15b  
\[23, 100, 40, 45, 45, 67, 32, 12, 5, 13, 53, 68\]  
\[5, 12, 13, 23, 32, 40, 45, 45, 53, 67, 68, 100\]