黑马程序员——JAVA学习笔记——面向对象（三大特性）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

1.封装
1.1概念:

指把对象的属性和行为看成一个密不可分的整体，将这两者“封装”在一个不可分割的独立单位（即对象中）；

优点：将变化隔离，便于使用，提高重用性和安全性。

在程序中的具体表现：把描述对象属性的变化和实现对象功能的方法合在一起，定义为一个程序单位，并保证外界不能任意更改其内部的属性值，也不能任意调动其内部的功能方法；常见为：getX();setY();

如单例设计模型：保证一个类在内存中的对象唯一性。

比如：多程序读取一个配置文件时，建议配置文件封装成对象。会方便操作其中数据，又要保证多个程序读到的是同一个配置文件对象，就需要该配置文件对象在内存中是唯一的。

此时使用Runtime()方法进行单例模型设计：

如何保证对象唯一性呢？

基本思路：A.不让其他程序创建该类对象

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

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

步骤：1，因为创建对象都需要构造函数初始化，只要将本类中的构造函数私有化，其他程序就无法再创建该类对象；

2，就在类中创建一个本类的对象；

3，定义一个方法，返回该对象，让其他程序可以通过方法就得到本类对象。

具体代码：

class Test{

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

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

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

return s;

}

}

或者

class Test{

private Test(){}

private static Test s = null;

public static Single getInstance(){

If(s==null){

s=newTest();

}

}

}

样板：

class Person{

private String name ; // 声明姓名属性

private int age ; // 声明年龄属性

public void setName(String n){ // 设置姓名

name = n ;

}

public void setAge(int a){ // 设置年龄

age = a ;

}

public String getName(){ // 取得姓名

return name ;

}

public int getAge(){ // 取得年龄

return age ;

}

public void tell(){

System.out.println("姓名：" + name + "，年龄：" + age) ;

}

};

public class Test{

public static void main(String arsgh[]){

Person per = new Person() ; // 声明并实例化对象

per.setName("张三") ; // 调用setter设置姓名

per.setAge(30) ; // 调用setter设置年龄

per.tell() ; // 输出信息

}

};



2.继承
使用继承的优点：

1：提高了代码的复用性，提高了软件的开发效率，降低了程序产生错误的可能性。

2：让类与类之间产生了关系，提供了另一个特征多态的前提。

首先拥有反映事物的一般特性的类，然后在其基础上派生出反映特殊事物的类。

目前面向对象程序设计中只出现单继承（即一个子类只能允许继承一个父类），但是JAVA可以通过接口（interface）执行多继承。

注意：

子类中所有的构造函数都会默认访问父类中的空参数的构造函数，因为每一个子类构造内第一行都有默认的语句super();

如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super语句指定要访问的父类中的构造函数。

如果子类构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数。

final特点：

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

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

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

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

抽象类的特点：

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

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

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

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

5: 抽象类只能单继承。

抽象类的细节：

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

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

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

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

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

接口与抽象类的区别：

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

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

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

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

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

接口使用的 like a 关系。

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

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

样板

abstractclass A{ // 是定义了一个抽象类

public static final String FROM ="CHINA" ; // 全局常量

private String name = "张三" ; // 定义一个普通的属性

public void setName(String name){

this.name = name ;

}

public String getName(){

return this.name ;

}

public abstract void print() ; // 定义抽象方法

};

classB extends A{ // 继承抽象类，因为B是普通类，所以必须覆写全部抽象方法

public void print(){

System.out.println("FROM = " +FROM) ;

System.out.println("姓名 = " +super.getName()) ;

}

};

publicclass Test{

public static void main(String args[]){

B b = new B() ;

b.print() ;

}

};



3.多态
多态是允许程序中出现重名现象，JAVA语言中含有方法重载和对象多态两种形式的多态。

1. 方法重载或覆写：在一个类中，允许多个方法使用一个名字，但是方法的参数不同，完成的功能也不同。

2. 对象多态：子类对象可以在父类对象进行相互转换，而且根据其使用的子类的不同，完成的功能也不同

优点：多态的特性是程序的抽象程度和简捷度更高，提高了程序的扩展性，有助于程序设计人员对程序的分组协同开发。

进行多态的前提：

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

2、 通常会有覆写操作。

方法的重载与覆写的区别：

重载：方法名称相同，参数的类型或个数不同，对权限没有要求，发送在一个类中。

覆写：方法名称、参数的类型、返回值类型全部相同，被覆写的方法不能拥有更严格的权限，发生在继承类中。

This 与super的区别：

This:访问本类中的属性，如果本类中没有次属性，则从父类中继续查找；

访问本类中的方法，如果本类中没有此方法，则从父类中继续查找；调用本类构造，必须放在构造方法的首行；表示当前对象。

Super:访问父类中的属性；直接访问父类中的方法；调用父类构造，必须放在子类构造方法的首行；

匿名内部类：

没有名字的内部类。就是内部类的简化形式。一般只用一次就可以用

这种形式。匿名内部类其实就是一个匿名子类对象。想要定义匿名内部类：需要前提，内部类必须继承一个类或者实现接口。

匿名内部类的格式：

new 父类名&接口名(){ 定义子类成员或者覆盖父类方法 }.方法。

匿名内部类的使用场景：

当函数的参数是接口类型引用时，如果接口中的方法不超过3个。可以通过匿名内部类来完成参数的传递。

其实就是在创建匿名内部类时，该类中的封装的方法不要过多，最好两个或者两个以内。

异 常：

异常处理原则：功能抛出几个异常，功能调用如果进行try处理，需要与之对应的catch处理代码块，这样的处理有针对性，抛几个就处理几个。

特殊情况：try对应多个catch时，如果有父类的catch语句块，一定要放在下面。

throw 和throws关键字的区别：

throw用于抛出异常对象，后面跟的是异常对象；throw用在函数内。

throws用于抛出异常类，后面跟的异常类名，可以跟多个，用逗号隔开。throws用在函数上。

样板代码1：

classOuter{ // 定义外部类

private String info = "helloworld" ; // 定义外部类的私有属性

class Inner{ //定义内部类

public void print(){ // 定义内部类的方法

System.out.println(info) ; // 直接访问外部类的私有属性

}

};

public void fun(){ // 定义外部类的方法

new Inner().print() ; // 通过内部类的实例化对象调用方法

}

};

publicclass Test{

public static void main(String args[]){

new Outer().fun() ; // 调用外部类的fun()方法

}

};

代码2：class Array{ // 表示数组

private int temp[] ; // 整型数组

private int foot ; // 定义添加位置

public Array(int len){

if(len>0){

this.temp = new int[len] ;

}else{

this.temp = new int[1] ; // 最少维持空间是1个

}

}

public boolean add(int i){ // 增加元素

if(this.foot<this.temp.length){ // 还有空间

this.temp[foot] = i ; // 增加元素

this.foot ++ ;// 修改脚标

return true ;

}else{

return false ;

}

}

public int[] getArray(){

return this.temp ;

}

};

classSortArray extends Array{ // 排序类

public SortArray(int len){

super(len) ;

}

public int[] getArray(){ // 覆写方法

java.util.Arrays.sort(super.getArray()) ; // 排序操作

return super.getArray() ;

}

};

classReverseArray extends Array{ // 反转操作类

public ReverseArray(int len){

super(len) ;

}

public int[] getArray() {

int t[] = newint[super.getArray().length] ; // 开辟一个新的数组

int count = t.length - 1 ;

for(int x=0 ;x<t.length;x++){

t[count] = super.getArray()[x] ; // 数组反转

count-- ;

}

return t ;

}

};

publicclass Test{

public static void main(String args[]){

// ReverseArray a = null ; // 声明反转类对象

// a = new ReverseArray(5) ; // 开辟5个空间大小

SortArray a = null ;

a = new SortArray(5) ;

System.out.print(a.add(23) +"\t") ;

System.out.print(a.add(21) +"\t") ;

System.out.print(a.add(2) +"\t") ;

System.out.print(a.add(42) +"\t") ;

System.out.print(a.add(5) +"\t") ;

System.out.print(a.add(6) +"\t") ;

print(a.getArray()) ;

}

public static void print(int i[]){ // 输出数组内容

for(int x=0;x<i.length;x++){

System.out.print(i[x] + "、") ;

}

}

};





------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------