面向对象

面向对象

作者 ki

第一章 类和对象

面向对象是指把问题看成若干个对象组成通过对象的属性及行为控制进行开发，比面向对象过程直观
结构更简单。
java是一种面向对象的编程语言。
在面向对象中，对象是用来描述客观事物的一个实例。
对象包括静态特征和动态特征。静态特征是可以用某些数据来描述的特征。  
方法是用来描述对象动态特征（行为）的一个序列。
封装就是把一个事物包装起来，并尽可能的隐藏内部细节。  
对象的属性是相辅相乘，不可分割的，他们共同组成了实体对象。
类定义了对象将会拥有的特征（属性)和行为（方法）。
因此类和对象的关系就是抽象和具体的关系。类是多个对象进行综合抽象的结果，是实体对象的概念  
模型，而一个对象是一个类的实例。  
语法：
访问修饰符 返回值类型 方法名（）{
//方法体  
}
语法：
类名 对象名=new 类名（）;
语法：
对象名.属性      //饮用对象的属性
对象名.方法名（）//信用对象的方法
数据类型的默认值
类型   ，默认值
int  0
double  0.0
char  '\u0000'
boolean  false
String  null
面向对象的优点：
类来模拟现实世界中的抽象概念没有对象来模拟现实世界的实体。
信息隐藏，提高了程序的可维护性和安全性：封装实现了模块化和信息隐藏，即将类的属性和行为封
装使得在对象外部不能随意访问对象的属性和方法，避免了外部错误对它的影响，提高了安全性。
 局部变量可以和成员变量同名，并且在使用时，局部变量具有更高的优先级。  

第二章 类的无参、带参方法

定义带参方法：  
<访问修饰符>返回类型<方法名>(<参数列表>）{
//方法的主体
}
调用参的方法：
对象名.方法名（参数1，参数2..，参数n）
如何导包：
语法：   
import 包名.类名;
import 包名.*;  
 
第三章 对象和封装

构造方法的名称和类名相同，没有返回值类型。构造方法的主要作用就是在创建对象时执行一些初始
化操作，如给成员属性赋初始值。
在没有给类提供任何构造方法时，系统会提供一个无参的方法体为空的默认方法。一旦提供了自定义  
的构造方法，系统将不再提供这个默认构造方法。如果要使用它，则程序必须手动添加。  
方法的重载：  
必须在同一个类李。
方法名相同。
参数列表（方法参数的个数或参数类型）不同。
与方法返回值和方法修饰符没有任何关系。   
在使用this调用自身的其他构造方法时，只能作为第一条语句。  
在加载类的过程中，完成静变量的内存分配，在执行静态块，两者实在创建对象之前执行的。
类属性和类方法可以通过类名和对象名访问，实例属性和实例方法只能通过对象名访问。
类方法只能访问属性和其他类方法。
静态方法中不能使用this和super关键字。super关键字。  
在方法里不能定义static变量，也就是说，类变量不能是局部变量。
‘构造方法’没有返回值类型。如果有，则不是构造方法，而是和构造方法同名的成员方法。
封装是面向对象的三大特性之一，就是将类的状态信息隐藏在类内部，不准外部程序直接访问，而是
通过该类提供的方法来实现对隐藏信息的操作和访问。
封装的具体步骤：修改属性的可见性来限制对属性的访问，为每个属性创建一对赋值（setter）方法
和取值（getter）方法，用于对这些属性的存取，在赋值方法中，加入属性的存取控制语句。
封装的好处：隐藏类的实现细节，让使用者只能通过程序规定的方法来访问数据，可以方便的加入存
取控制语句，限制不合理的操作。
属性的封装将属性私有化提供公有的方法来访问私有属性。
private:成员变量和方法只能在器定义的泪痣给你被访问，具有类的可见性。
默认：成员变量和方法只能被同一个包里的类访问，具有包可见性。
protected:可以被同一个包中的类访问，被同一个项目中不同的包中的子类访问（父类、
子类）
public：可以被同一个项目中的所有类访问，具有项目可见性，这是最大的访问权限。

第四章 继承  
  
语法      
修饰符 SubClass extends SuperClass{                                                       
//类定义部分    
}
继承是通过extends关键字来实现的，其中的SubClass称为子类，superClass称为父类（基类过超类）
修饰符是public，则该类在整个项目可见；无public修饰符，则该类只在当前包可见；不可以使用
private和protected修饰符。
继承是面向对象的三大特征之一，java只支持单继承，即每个类智能有一个直接父类。
继承public 和protexted修饰的属性和方法，无论子类和父类是否在同一个包里。
继承默认权限修饰符的属性很方法，但子类和父类必须在同一个包里。  
无法继承private修饰的属性和方法。
无法继承父类的构造方法。
构造方法只能通过super调用。
重写和继承关系中的构造方法：
如果从父类继承方法不能满足子类的需求，则在子类中可以对父类的同名方法进行重写（覆盖），以符
合需求。  
重写方法和被重写方法必须具有相同的方法名。
重写方法和被重写方法必须具有相同的参数列表。
重写方法的返回值必须和被重写的方法的返回类型形同活是器子类。
重写方法不能缩小被重写方法的访问权限。  
super代表对当前对象的直接父类对象的默认引用。在子类中可以用super直接对父类成员和构造方法进   
行引用。   
super 必须出现在子类（子类的方法喝构造方法）中，而不是其他位置。  
可以访问父类的成员，如父类属性、方法、构造方法。   
注意访问权限的限制，如无法通过super访问private成员。
super.name;//访问直接父类的name属性
super.print();//访问直接父类的print()方法
super(name);//访问直接父类对应的构造方法，只能出现在构造方法，只能出现在构造方法中
Object类的重写
Object类是所有类的父类。
所有的java类都直接或间接的继承了java.lang.Object类。Object类的所有Java类的祖先。在定义一个
类时。没有使用extends关键字，也就是没有显示的继承了某个类，那么这个类直接继承Object类
方法 说明
toString () 返回当前对象本身的有关信息，按字符串对象返回
equals () 比较两个对象是否是同一个对象，若是，返回true
clone () 生成当你前对象的一个副本，并返回
hashCode () 返回该对象的哈希码值
getClass () 获取挡墙对象所有属性的类信息，返回Class对象
继承关系的构造方法
一个类的构造放法在两种情况下会被调用
1.创建该类的对象
2.创建该类子类的调动
子类在实例化时先执行父类的构造方法，然后才执行自身的构造方法。
继承条件下的构造方法的调用规则如下
如果子类的构造方法中没有通过super显示调用父类的有参构造方法，也没有通过this显示调用自身的其
它构造方法，则系统会默认先调用父类的无参构造方法，在这种情况下有没有super（）语句都一样
如果子类的构造方法中通过super显示调用父类的有参构造方法，则将执行父类相应的构造方法，而不是
执行父类无参构造方法。
如果子类的构造方法中通过this显示调用自身的其他构造方法，则在相应构造方法中应用以上两条规则。
需要特别注意的是，如果存在多级继承关系，则在创建一个子类对象时，以上规则会多次向更高一级父
类应用，一直到执行顶级父类Object类的无参构造方法为止。
注意：
构造方法中如果有this或super语句出现，则只能是第一语句。
在一个构造方法中不准同时出现使用this和super语句调用构造方法（否则就有两条第一条语句）
在类方法中不准出现this和super关键字。
在实例方法中，this和super语句不是要求第一条语句，可以共存。
抽象类
可以使用Java中的抽象类来实现，用abstract来修饰print（）方法，则子类必须重写该方法。
注意：
"public void print(){}"不是抽象方法而是有实现为空的普通方法。
"public abstract void print(){};"是抽象方法，别忘记最后的最后的分号
abstract 可以用来修饰类和方法，但不能从来修饰属性和构造方法。
问答：
问： 修饰类中可以有构造方法吗？
答： 抽象类可以有构造方法，其构造方法可以被本类的其他构造方法调用，若此构造方法不是由private
修饰的，也可以被本类的子类中的构造方法调用。
final的应用
用final修饰的类不能再被继承final class  dog{}
用final修饰的方法不能再被继承public final void print （）{}
final和abstract是功能相反的两个关键字
abstract可以用来修饰类的方法，不能修饰属性和构造方法。final可以用来修饰类、方法和属性，不能修饰
构造方法。
java提供的很多类都是final类，如Sring类、Math类，它们不能再有子类。Object类中一些方法，如getClass()
notify()、wait()都是final方法，只能被子类继承而不能被重写，但是hashCode()、toString()、equals（Object）
不是final的方法，可以被重写。


第五章 多态


多态表现多种形态能力的特征。同一个实现接口，使用不同的实例而执行不同的操作。
使用相同的父类引用赋给它不同的子类对象调用相同的方法呈现不同的结果。
子类到父类的转化
将一个父类的应用指向一个子类对象，称为向上转型，自动进行类型转化。
此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法。
此时通过父类引用变量无法调用子类特有的方法。
多态：1形参2返回值
使用父类作为方法的形参，是java中实现和使用多态的主要方式之一。
使用父类作为方法的返回值，是java中实现和使用多态的另一种方式。


面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一
个概念，也是最重要的知识点。
多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为
方式。（发送消息就是函数调用）
实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类
型调用其相应的方法。
多态的作用：消除类型之间的耦合关系。
现实中，关于多态的例子不胜枚举。比方说按下 F1 键这个动作，如果当前在 Flash 界面下弹出的就是 AS 3 的帮助
文档；如果当前在 Word 下弹出的就是 Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发
生在不同的对象上会产生不同的结果。
多态存在的三个必要条件
一、要有继承；
二、要有重写；
三、父类引用指向子类对象。
多态的好处：


1.可替换性（substitutability）。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆
形几何体，如圆环，也同样工作。
2.可扩充性（extensibility）。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其
他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，
很容易增添球体类的多态性。
3.接口性（interface-ability）。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它
而实现的。如图8.3 所示。图中超类Shape规定了两个实现多态的接口方法，computeArea()以及computeVolume()。子
类，如Circle和Sphere为了实现多态，完善或者覆盖这两个接口方法。
4.灵活性（flexibility）。它在应用中体现了灵活多样的操作，提高了使用效率。
5.简化性（simplicity）。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特
点尤为突出和重要。


Java中多态的实现方式：接口实现，继承父类进行方法重写，同一个类中进行方法重载。


第六章 接口


在软件中，接口同样是一种规范和标准，他们可以约束类的行为，是一些方法特征的集合，但是没有方法的实现。
语法：
【修饰符】interface 接口名extends 父接口1，父接口2,。。。{
//常量定义
//方法定义
}
语法
class 类名extends父类名implements接口1，接口2，。。。。{
//类成员
}
接口的命名与类名相同，如果修饰符石public，则该接口在整个项目中可见；如果省略修饰符，则接口只在当前包可见。
接口中可定义常量，不能定义变量。接口中的属性都会自动用public static final修饰，即接口中的属性都是全局静态
常量。接口中的常量必须在定义时指定初始值。
例如：
public static final int PI=3.14;
int PI=3.14;//在接口中。这两个定义语句效果完全相同
int PI;//错误！在接口中必须指定初始值，在类中会有默认值
接口中所有的方法都是抽象方法。接口中方法都会自动用public abstact 修饰，即接口中只有全局抽象方法。
和抽象类一样，接口也不是实例化，接口中不能有构造方法。
接口之间也可以通过extends 实现继承关系，一个接口可以继承多个接口，但接口不能继承类
接口的实现类必须实现接口的全部方法，否则必须定义为抽象类
一个类只能有一个直接父类，但可以通过implements实现多个接口。当类在继承父类的同时又实现了多个接口时，extends
关键字必须位于implements关键字之前


第七章 异常


异常中的五个关键字->try,catch,finally,throw和throws来实现的。
try-catch有三种情况
1.try中语句正常执行，不会发生异常，那么catch块中的所有语句都会被忽略。
2.try中语句执行中遇到异常，并且这个异常与catch中声明的异常类型相匹配，那么try块中其余剩下的代码都将被忽略，
catch块将被执行。匹配是指catch所处理的的异常类型与所生成的异常类型完全一致或是它的父类。
3.如果try语句块在执行过程中遇到异常，而抛出的异常catch块里没有被声明，那么程序立刻退出。
常见异常类型
异常 说明
Exception 异常层次结构的根类
ArithmeticException 算数错误情形，如以零作为除数
ArrauIndexOutOfBoundsException 数组下标越界
NullPointerException 尝试访问null对象成员
ClassNotFoundException 不能加载所需的类
InputMismatchException 欲得到的数据类型与实际输入的数据类型不匹配
IllegalArgumentException 方法接收到非法参数
ClassCastException 对象强制类型转换出错
NumberFormatException 数字格式转换异常，如把“abc”转换成数字
try-catch-finally块
无论是否发生异常，finally块中的代码总能被执行
多重catch块一段代码可能会引发多种类型的异常，这时可以在一个try语句块后面跟多个catch语句块，分别处理不同的异常，
但顺序必须是从子类到父类，最后一个一般都是Exception类。


1. 成员变量和局部变量的区别
1）在类中的位置不同
成员变量：类中方法处
局部变量：方法定义中或者方法声明上
2）在内存的位置不同  
成员变量：在堆中  
局部变量：在栈中类定义了对象将会拥有的特征（属性)和行为（方法）。
3）生命周期不同  
成员变量：随着对象的创建而存在，随着对象的消失而消失  
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
4）初始化值不同  
成员变量：有默认值  
局部变量：没有默认值，必须定义，赋值，然后才能使用
2.类作为形式参数的问题？
1）如果你看到一个方法需要的参数是一个类名，就应该知道哲这里实际需要的是一个
具体的对象
3.匿名对象
1）没有名字的对象
2）应用场景
A：调用方法，仅仅只调用一次的时候
b：可以作为实际参数传递
4.封装
1）隐藏实现细节，提供公共的访问方式
2）好处：
A：隐藏实现细节，提供公共的访问方式
B：提高代码的复用性
C：提高代码的安全性
3）设计原则
把不想让外界知道的实现细节给隐藏起来，提供公共访问方式
4）private是封装的一种体现  
封装：类，方法，private修饰成员变量

5.private关键字
1）私有的意义，可以修饰成员变量和成员方法
2）特点：  
被private修饰后的成员只能在本类中被访问
3）private的应用：  
 以后再写一个类的时候：
把所有的成员变量给private了
提供对应的getXxx()/setXxx()方法

6.this关键字
1）代表当前类的引用对象   
记住：那个对象调用方法，该方法内部的this就代表那个对象
2）this的应用场景   
A：解决了局部变量隐藏成员变量的问题   
B：其实this还有其他的应用
7.构造方法
1）作用：用于对对象的数据进行初始化
2）格式   
A：方法：用于对对象的数据进行初始化   
B：没有返回值类型，练void都不能有   
C：没有返回值
 
思考题：构造方法中可不可以有return语句那？
可以。而我们写成这个样子就OK了：retirn;
其实，在任何的void类型的方法的最后你都可以写上：return；
3）构造方法的注意事项   
A：如果我们没写成构造方法，系统将提供一个默认的无参构造方法   
B：如果我们给出了构造方法，系统将不在提供默认构造方法。
如果这个时候，我们要使用无参构造方法，就必须自己给出。
推荐：永远手动自己给出无参构造方法
4）给成员变量赋值的方式   
A：setXxx()   
B:带参构造方法

8.标准案例
Student s=new Student();做了哪些
1）把Studnet.class文件加载到内存
2）在栈内存为s开辟空间
3）在对内存为学生对象申请空间
4）给学生的成员变量进行默认初始化。null,0
5）给学生的成员变量进行显示初始化。
6）通过构造方法给成员变量进行初始化。
7）对象构造完毕，吧地址赋值给s变量

9.static关键字
1）静态的意思。可以修饰成员变量和成员方法。
2）静态的特点：   
A：随着类的加载而加载   
B：有限于或有对象共享  
C：被类的所有对象共享      
这其实也是我们判断该不该使用静态的依据      
举例：饮水机和水杯的问题思考                                                       
D：可以通过类名调用      
既可以通过对象名调用，也可以通过类名调用，建议通过类名调用
3）静态内存图   静态的内容在方法去的静态区
4）静态的注意事项   
A：所属不同
静态变量：属于类，类变量
成员变量：属于对象，对象变量，实例变量   
B：内存位置不同
静态变量：方法区的静态区
成员变量：堆内存   
C：生命期不同
静态变量：静态变量是谁着类的加载而加载，随着类的消失而消失
成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失   
D通用不同
静态变量：可以通过对象名调用，也可以通过类名调用
成员变量：只能通过对象名调用
6）main方法是静态的   
public：权限最大   
static：不用创建对象调用   
void：返回值给jvm没有意义  
main：就是一个常见的名称   
String[] args：可以接受数据，提供程序的灵活性