java-studyDay03-面向对象

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

　　 //格式

　　　　/**

　　　　　*类描述

　　　　　*@author 作者名

　　　　　*@version 版本号

　　　　　*/

　　　　/**

　　　　　*方法描述

　　　　　*@param 参数描述

　　　　　*@return 返回值描述

　　　　　*/

面向对象

1. 特点

   • 将复杂的事情简单化。

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

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

2. 面向对象

   面向对象编程(Object-Oriented Programming, OOP) 面向对象编程的本质就是:以类的方式组织代码，以对象的组织(封装)数据。 抽象 三大特性:

   • 封装

   • 继承

   • 多态 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象 从代码运行角度考虑是先有类后有对象象。类是对象的模板。

3. 回顾方法

   方法的定义

   • 修饰符

   • 返回类型

   • break：和return 的区别

     • break：跳出Switch，结束循环 ；

     • return ：结束方法，返回一个结果。

   • 方法名：注意规范，见名知意

   • 参数列表：（ 参数类型，参数名 ） (int… num) 可变参数

   • 异常抛出

   • 方法的调用：递归

   • 静态方法

   • 非静态方法

   • 形参和实参

   • 值传递和引用传递

   • this关键字 : 指向类中的属性；

4. 类与对象的关系

   类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但并不能代表某一个具体的事物。 动物、植物、手机、电脑… Person类、Pet类、Cat类等，都是用来描述/定义某一具体的事物应该具备的特点和行为。 对象是抽象概念的具体实例， 如张三是人的一个具体实例、张三家里的狗旺财就是狗的一个具体实例。 能够体现出特点,展现出功能的是具体的实例,而不是一个抽象的概念。

5. 创建与初始化对象

    

   • 使用new关键字来创建对象。

   • 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化，以及对类中构造器的调用。

   • 类中的构造器也被称为构造方法，是在进创建对象时必须要调用。并且构造器有以下特点： 必须和类的名字相同 必须没有返回类型，也不能写void

   ​ 构造器必须掌握

   • 一个类即使什么都不写，也会存在一个默认的构造方法

    

    

    

   构造器： 1.和类名相同 2.没有返回值 作用： 1.new 本质在调用构造方法 2.初始化对象的值 注意点： 1.定义有参构造之后，如果使用无参构造，显示的定义一个无参的构造(定义有参的时候，默认生成的无参被覆盖了，所以需要自己重新定义一个无参构造) Alt+ Insert :Generate(生成)

   

6. 封装:

   该露的露，该藏的藏 我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。 封装（数据的隐藏) 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。 记住这句话就够了:

   属性私有，get/set

    

    

   封装的好处： 1.提高程序的安全性，保护数据 2.隐藏代码的实现细节 3.统一接口 4.系统可维护性增加了

　注意：用this调用构造函数，必须定义在构造函数的第一行。

　　因为构造函数是用于初始化的，所以初始化动作一定要执行。否则编译失败

static** 关键字，是一个修饰符，用于修饰成员(成员变量和成员函数)。

　　特点：

　　　　1，想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。

　　　　2，被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。

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

　　弊端：

　　　　1，有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述

就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。

　　　　2，静态方法只能访问静态成员，不可以访问非静态成员。

　　　　　　因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。

　　　　3，静态方法中不能使用this，super关键字。

　　　　　　因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。

　　　　4，主函数是静态的。

7. 继承

   继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。 extends的意思是“扩展”。子类是父类的扩展。 JAVA中类只有单继承，没有多继承!(一个儿子只能有一个亲爹，但是亲爹却可以有多个儿子) 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。 继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。 子类和父类之间,从意义上讲应该具有"is a"的关系。

   object类 super 方法重写 super注意点:

   1. super调用父类的构造方法，必须在构造方法的第一个

   2. super 必须只能出现在子类的方法或者构造方法中!

   3. super和 this不能同时调用构造方法!

   this: 代表的对象不同:

   this:本身调用者这个对象

   super:代表父类对象的应用 前提： this:没有继承也可以使用 super:只能在继承条件才可以使用 构造方法 this(）; 本类的构造 super(): 父类的构造! 重写 : 需要有继承关系，子类重写父类的方法!. 1．方法名必须相同 2．参数列表列表必须相同 3．修饰符:范围可以扩大但不能缩小: public>protected>Default>private 4．抛出的异常:范围，可以被缩小，但不能扩大; ClassNotFoundException --> Exception(大) 重写，子类的方法和父类必要一

   致; 方法体不同!

    

   为什么需要重写: 1．父类的功能，子类不一定需要，或者不一定满足! Alt +Insert ; override;

方法重写

　　单继承：一个类只能有一个父类。

　　多继承：一个类可以有多个父类。

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

 

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

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

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

 

final关键词

final特点：

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

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

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

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

8. 多态

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

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

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

   　　多态的前提：

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

   　　　　2：通常会有覆盖操作。

    

   　　多态的出现思想上也做着变化：以前是创建对象并指挥对象做事情。有了多态以后，我们可以找到对象的共性类型，直接操作共性类型做事情即可，这样可以指挥一批对象做事情，即通过操作父类或接口实现。

　

　注意:多态是方法的多态，属性没有多态性。

 

Object：所有类的直接或者间接父类，Java认为所有的对象都具备一些基本的共性内容，这些内容可以不断的向上抽取，最终就抽取到了 一个最顶层的类中的，该类中定义的就是所有对象都具备的功能。

多态注意事项:

1.多态是方法的多态，属性没有多态 2.父类和子类，有联系 类型转换异常! CLassCastException ! 3．存在条件: 继承关系，方法需要重写，父类引用指向子类对象! Father f1 = new Son();

不能被重写的方法：

static方法，属于类，它不属于实例 final 常量; private方法;

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

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

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

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

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

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

2，成员函数。

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

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

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

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

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

3，静态函数。

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

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

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

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

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