java基础-面向对象

面向对象-是一种设计思想（以人（拟人）的角度完成某种任务）

面向对象的四大特性

封装 ：在面向对象语言中，封装特性是由类来体现的，我们将现实生活中的 一类实体定义成类 ，其中包括 属性和行为 （在Java中就是方法），就好像人类，可以具有name,sex,age等属性，同时也具有eat(),sleep()等行为，我们在行为中实现一定的功能，也可操作属性，这是面向对象的封装特性；

抽象 ：抽象就是将 一类实体的共同特性抽象出来，封装在一个抽象类 中，所以抽象在面向对象语言是由抽象类来体现的。比如鸟就是一个抽象实体，因为抽象实体并不是一个真正的对象，它的属性还不能完全描述一个对象，所以在语言中体现为抽象类不能实例化；

继承 ：继承就像是我们现实生活中的父子关系，儿子可以 遗传 父亲的一些特性，在面向对象语言中，就是一个类可以继承另一个类的一些特性，从而可以代码重用，其实继承体现的是is-a关系，父类同子类在本质上还是一类实体；

多态 ：多态就是通过传递给父类对象引用不同的子类对象从而表现出不同的行为

一种数据，多种表现方式

一、变量部分

类：事物的抽象（属性-成员变量）和（行为-成员方法）---属性属于这个类所创建的对象

对象：是类的具体事例

1、局部变量：

声明在方法，构造方法或者块语句中的变量，局部变量在方法、构造方法、或者语句块被执行的时候创建，方法结束后，变量就会自动销毁

访问修饰符不能用于局部变量

局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

局部变量是在 栈 上分配的。

局部变量不能被声明为 static 变量

2、类变量（静态变量）：独立于方法之外的变量，用 static 修饰。

类变量也称为静态变量，在类中以static关键字声明，但必须在方法构造方法和语句块之外。

无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。

静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。

静态变量储存在静态存储区 。经常被声明为常量，很少单独使用static声明变量。

静态变量在程序开始时创建，在程序结束时销毁。

与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。

默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。

静态变量可以通过：ClassName.VariableName的方式访问。

类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。

3、成员变量：声明在类中，方法体之外的变量。成员变量在声明的时候进行实例化（实例变量属于成员变量）。成员变量可以可以被类中方法构造方法和特定的语句块访问

4、实例变量：实例变量声明在一个类中，但在方法、构造方法和语句块之外；

当一个对象被实例化之后，每个实例变量的值就跟着确定；

实例变量在对象创建的时候创建，在对象被销毁的时候销毁；

实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；

实例变量可以声明在使用前或者使用后；

访问修饰符可以修饰实例变量；

实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；

实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；

实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。

O1-静态变量和实例变量的区别？

  静态变量也称作类变量，由static修饰，如：static int s; s就是静态变量，它只能通过类来访问。

实例变量没有static修饰符，它只能通过实例对象来访问。

  同一类的不同的实例对象有自己的实例变量，但是它们共享同一个静态变量。当一个实例对象修改了它的实例变量时，不会影响其他的实例对象。如果一个实例对象修改了静态变量，则会影响其他的对象实例。

 在java中类的静态变量在内存中只有一个，java虚拟机在加载类的过程中为静态变量分配内存， 静态变量位于方法区，被类的所有实例共享 。静态变量可以直接通过类名进行访问，其生命周期取决于类的生命周期。

 而实例变量取决于类的实例。每创建一个实例，java虚拟机就会为实例变量分配一次内存， 实例变量位于堆区中 ，其生命周期取决于实例的生命周期。

二、创建对象

1、声明一个对象，包括对象名称和对象类型

2、实例化对象：使用new来创建一个对象

创建对象除了new之外，还有其他的方法

调用对象的clone方法、

• 实现clone的类首先需要继承cloneable接口。Cloneable接口实质上是一个标识接口，没有任何接口方法
• 在类中重写Object类的clone方法
• 在clone方法中调用super.clone()。无论clone类的继承结构是什么，super.clone()都会直接或者间接调用java.lang.Object类的clone方法

通过反射机制来创建对象

通过反序列化的方式来创建对象

3、初始化：使用new创建对象时，调用构造方法初始化对象

在java语言中，当实例化对象时，对象所在类的所有成员变量首先要进行初始化，只有当所有成员完成初始化后，才会调用对象所在类的构造函数创建对象

程序初始化遵循的三个原则（优先级依次降低）

(1、静态对象（变量）优先于非静态对象（变量）初始化，其中，静态对象（变量只初始化一次，而非静态对象（变量）可能初始化多次）

(2、父类优先于子类进行初始化

(3、按照成员变量定义顺序进行初始化，即使变量定义散布于方法定义中，它们依然在任何方法（包括构造函数）调用之前先初始化

4、构造方法的特点

• 构造方法必须与类名相同，并且不能由返回值（包括void）
• 每个类可以有多个构造方法。当开发人员没有提供构造方法时，编译器会自动生成一个没有参数的默认的构造方法，但该构造方法不会执行任何代码。
• 构造方法可以有0个或者多个参数
• 构造方法总是伴着new一起使用，不能由程序的调用者直接使用，必须由系统调用 构造方法在对象实例化时会被自动调用，且只运行一次，而普通方法则是在程序执行它时才被调用，并且可以被对象调用多次
• 构造方法的主要作用是完成对对象的初始化
• 构造方法不能被继承，因此不能被覆盖，但是构造方法能够被重载，可以使用不同的参数个数或者参数类型来定义多个构造方法
• 子类可以通过super关键字来显式的调用父类的构造方法，当父类没有提供无参数的构造方法时，子类的额构造方法就必须显式的调用父类的构造犯法。如果父类提供了无参的构造方法，那么子类就可以不显式的调用父类的构造方法，在这种情况下，编译器会默认的调用 父类的构造方法。当有父类时，在实例化对象时，会首先执行父类的构造犯法，然后执行子类的构造方法
• 当父子类中都没有构造方法时，编译器会自动的给父子类生成默认的无参构造，此时，只与当前类的修饰符有关

O2---当一个对象被当做参数传递到一个方法后，此方法可以改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递？

答:是值传递。Java编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不变的。

三、static关键字的作用

static 描述的成员变量不再属于对象

static修饰的信息属于这个类创建的对象共有的

类的信息

静态方法体里，只能使用静态信息 （公共时影响其他）

修饰成员变量和成员方法;所以把static修饰的信息称之为与类相关，与对象无关，因此，

在static修饰的方法体内，不能直接使用非static修饰的成员变量和成员方法

static 还可以修饰内部类，static为类信息，为对象所共有，类信息被加载时进行赋值

O4 ---是否可以从一个static方法内部发出对非static方法的调用？

    解答1-不可以,如果静态方法内部包含对象的非静态方法的调用则不能保证对象初始化，所以不能在静态的方法里调用非静态的方法。

解答2-不可以。因为非static方法是要与对象关联在一起的，必须创建一个对象后， 才可以在该对象上进行方法调用，而static方法调用时不需要创建对象，可以 直接调用。也就是说，当一个static方法被调用时，可能还没有创建任何实例 对象，如果从一个static方法中发出对非static方法的调用，那个非static 方法是关联到哪个对象上的呢？这个逻辑无法成立，所以，一个static方法内部 发出对非static方法的调用。

四、final关键字

使用final关键字修饰一个引用类型变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。

1、final修饰的成员变量，形参变量，局部变量 只可以赋初值一次，赋初值完成之后不允许被修改

（1、属性处直接赋初值 2、块语句对其赋值 3、方法体中赋初值)

2、final修饰的方法不能被重写

3、final修饰的类不能被继承

4、static final 修饰的变量（称之为常量）必须在定义时赋初值，不能利用方法体对变量进行赋值。因为对象被创建，构造方法就会被调用，就会对变量进行一次赋值（利用构造方法的特性）

5、final, finally, finalize的区别     

final---如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。　

finally---在异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话） 

finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。

finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的

五、多态-一种数据类型，多种表现方式

静态多态-重载

动态多态包括-继承·方法的重写·将子类对象的引用赋值给父类的对象

1、重写(Override)中需要注意的问题-重写方法可以与原来方法的返回值不同但两个返回值之间要存在继承关系

• 重写方法与原来方法的签名要相同，即方法名称和参数，顺序要相同
• 重写方法的可见性不能小于原来的方法
• 重写方法抛出异常的范围不能大于原来方法抛出异常的范围

@Override注解：可以测试该方法是否重写了父类中的方法，如果没有则会在编译时报错。

O3---Overload和Overriding的区别。Overloaded的方法是否可以改变返回值的类型?

方法的重写Overriding和重载Overloading是Java多态性的不同表现。

Overriding是 父类与子类之间多态性的一种表现 ，Overloading是 一个类中多态性的一种表现 。

如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。

子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。

如果在一个类中定义了多个同名的方 法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载

Overloaded的方法是可以改变返回值的类型。

2、静态绑定和动态绑定

java中动态绑定的好处：提高了程序设计的灵活性，降低了耦合性

静态数据类型绑定---发生在代码的编译阶段---只看定义阶段的数据类型----因为类型决定功能，决定方法的调用

动态数据类型绑定---运行阶段

java中属于静态绑定的有 类属性、构造方法、声明为static的静态方法

声明为final的方法 ，将其列为另外一个项目，声明为private的方法

使用关键字super调用的方法

静态绑定的好处：性能好，提高代码的运行速度,所以在资源有限，又对程序性能要求比较高的地方，可以适当多用一些静态绑定

六、接口和抽象类

声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。

接口（interface）（Java中的接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能））是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有 程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。 然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到 接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

instanceof ：该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。

接口(interface)和抽象类（abstract class）的区别

接口与 抽象类的相同点

①都不能被实例化

②接口的实现类或者抽象类的子类都只有实现了接口或者抽象类中的方法后才能被实例化

不同点

① 接口只有定义，不能有方法的实现，而抽象类可以有定义和实现，即其方法可以在抽象类中实现

②实现接口类的关键字为implements，继承抽象类的关键字为extends。一个类可以实现多个接口，但一个类只能继承一个抽象类，因此，使用接口可以间接的达到多重继承的目的

③接口强调特定功能的实现，而抽象类强调所属关系

④接口被运用于实现比较常用的功能，便于日后维护或者添加删除方法而抽象类更倾向于充当公共类的角色，不适用于日后重新对里面的代码进行修改

七、内部类和外部类

内部类：在一个类内部定义一个类

内部类具有外部类的一切功能

内部类被创建，一定有外部对象

内部类的好处

能继承 实现接口 在内部类里面可以直接使用 外部类的私有的成员变量

基本 静态 局部

静态内部类只能使用外部类里静态的信息，而不能使用非静态的信息

1、Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)? 

            可以继承其他类或完成其他接口，在swing编程中常用此方式。

2、内部类可以引用他包含类的成员吗？有没有什么限制？

一个内部类对象可以访问创建它的外部类对象的内容

3、Static Nested Class 和 Inner Class的不同

Nested Class （一般是C++的说法），Inner Class (一般是JAVA的说法)。Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。

注： 静态内部类（Inner Class）意味着1.创建一个static内部类的对象，不需要一个外部类对象，2.不能从一个static内部类的一个对象访问一个外部类对象

4、一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？

可以。必须只有一个类名与文件名相同。Public的类必须和文件名相同，并且一个.java的源文件中只能有一个公有的类。

八、继承

属性不允许被继承，被继承的只有方法

构造方法不允许被继承

静态，私有方法不能被继承

九、封装

封装给对象提供了隐藏内部特性和行为的能力。对象提供一些能被其他对象访问的方法来改变它内部的数据。不同修饰符提供不同的访问权限。

封装的好处

• 通过隐藏对象的属性来保护对象内部的状态
• 提高了代码的可用性和可维护性。因为对象的行为可以被单独的改变或者是扩展
• 禁止对象之间的不良交互提高模块化

十、抽象类应当拥有尽可能多的共同代码,

好处：可以提高代码的复用率

代码在共同的类中出现，那么在代码发生改变时，设计师只需要 修改一个地方。这对代码的复用性提高是有好处的

并且，一个对象从父类继承而来的代码，在不使用时不会造成资源的浪费

再者，抽象类应当拥有尽可能少的数据，这样可以保证节省内存资源

一个对象的数据不论是否使用都会占用资源，因此数据应当尽量放到具体类或者等级结构的低端

变量被声明时的类型叫做变量的静态类型

引用的对象的真实类型叫做变量的实际类型