---------------------- android培训、java培训、期待与您交流! ----------------------
面向对象程序设计具有以下特点:
封装性
继承性
多态性
一,封装
封装是面向对象编程的核心思想,将对象的属性和行为封装起来,而将对象的属性和行为封装起来的载体就是类,类通常对客户隐藏其实现细节,这就是封装的思想。例如用户使用电脑,只需要使用手指敲击键盘就可以实现一些功能,用户无须知道电脑内部是如何工作的,如果用户可能碰巧知道电脑的工作原理,但在使用电脑时并不完全依赖于电脑工作原理这些细节
采用封装的思想保证了类内部数据结构的完整性,应用该类的用户不能轻易直接的操纵此数据结构,用户只能执行类允许公开的数据。这样避免了外部对内部数据的影响,提高程序的可维护性。
好处:
1,将变化隔离
2,便于使用
3,提高重用性
4,提高安全性
封装原则:
1,概述:类与类之间同样具有关系,比如一个百货公司类与销售员类相联系,类之间这种关系被称为关联。关联是描述两个类之间的一般二元关系,例如,一个百货公司类与销售员类就是一个关联,再比如学生类以及教师类也是一个关联,两个类之间的关系有很多种,继承是关联中的一种。
多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继那个类即可。 多个类可以称为子类,单独这个类称为父类或者超类。子类可以直接访问父类中的非私有的属性和行为,通过extends 关键字让类与类之间产生继承关系,格式是:
class SubDemo extends Demo{}
2,好处:
1)继承的出现提高了代码的复用性。
2)让类与类之间产生了关系。有了这个关系,才有了多态的特性。
3,注意:
1)千万不要为了获取其他类的功能,简化代码而继承。必须是类与类之间有所属关系才可以继承。所属关系 is a。
2)Java语言中:java只支持单继承,不支持多继承。
因为多继承容易带来安全隐患:当多个父类中定义了相同功能,当功能内容不同时,子类对象不确定要运行哪一个。但是java保留这种机制。并用另一种体现形式来完成表示。多实现。
class SubDemo extends Demo{} //ok
class SubDemo extends Demo1,Demo2...//error
3)java支持多层继承。也就是一个继承体系,比如:
class C{}
class A extends C{}
class B extends A{}
如何使用一个继承体系中的功能呢?
想要使用体系,先查阅体系父类的描述,因为父类中定义的是该体系中共性功能。通过了解共性功能,就可以知道该体系的基本功能。那么这个体系已经可以基本使用了。
那么在具体调用时,要创建最子类的对象,为什么呢?
一是因为有可能父类不能创建对象,
二是创建子类对象可以使用更多的功能,包括基本的也包括特有的。
简单一句话:查阅父类功能,创建子类对象使用功能。
说明:子类不可以具备父类中私有的内容。
3,子父类出现后,类成员的特点
类中成员:
1),变量:
当子父类中定义了相同的名称的成员变量,子类要使用父类中的同名变量时,需要使用关键字super来区分。一般不会出现这种情况,因为父类中有了,子类不需要定义。而且父类定义时,一般变量都私有化。
如果子类中出现非私有的同名成员变量时,子类要访问本类中的变量用this,子类要访问父类中的同名变量用super。
super的使用和this的使用几乎一致。this代表的是本类对象的引用。super代表的是父类对象的引用。
2),函数(覆盖):
当子类出现和父类一模一样的函数时,子类对象调用该函数,会运行子类函数的内容。如同父类的函数被覆盖一样。
这种情况是函数的另一个特性:重写(覆盖)
当子类继承父类,沿袭了父类的功能,到子类中,但是子类虽具备该功能,但是功能的内容却和父类不一致,
这时,没有必要定义新功能,而是使用覆盖特殊,保留父类的功能定义,并重写功能内容。
覆盖:
1,子类覆盖父类,必须保证子类权限大于等于父类权限,才可以覆盖,否则编译失败。
2,静态只能覆盖静态。
3,构造函数。
注意:
重载:只看同名函数的参数列表。
重写:子父类方法要一模一样。
下面一段代码实现的就是子类覆盖父类的方法:
class Fu //定义一个父类
{
void show()//定义父类的show函数
{
System.out.println("fu show");
}
}
class Zi extends Fu//定义一个子类继承父类
{
void show()//子类的show方法覆盖父类的show方法
{
System.out.println("zi show");
}
}
class ExtendsDemo
{
public static void main(String[] args)
{
Zi z = new Zi();//创建子类对象
z.show();//调用子类show函数
}
}
4,子父类中的构造函数
在对子类对象进行初始化时,父类的构造函数也会运行,那是因为子类的构造函数默认第一行有一条隐式的语句 super();super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();
为什么子类一定要访问父类中的构造函数?
因为父类中的数据子类可以直接获取。所以子类对象在建立时,需要先查看父类是如何对这些数据进行初始化的。
所以子类在对象初始化时,要先访问一下父类中的构造函数。
如果要访问父类中指定的构造函数,可以通过手动定义super语句的方式来指定。
注意:super语句一定定义在子类构造函数的第一行。
子类的实例化过程。
结论:
子类的所有的构造函数,默认都会访问父类中空参数的构造函数。
因为子类每一个构造函数内的第一行都有一句隐式super();
当父类中没有空参数的构造函数时,子类必须手动通过super语句形式来指定要访问父类中的构造函数。
当然:子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。
子类中至少会有一个构造函数会访问父类中的构造函数。
说明:父类中的构造函数也是隐式了一个super();语句,因为所有类的父类是object
比如下面一段代码:
class Fu //extends Object 这里父类也是object的子类
{
int num ;
Fu()//父类的空参数构造函数
{
//super();//所以这里隐式了一个super(); 可以不写,写了也没什么意义
num= 60;
System.out.println("fu run");
}
Fu(int x)//父类的有参构造函数
{
System.out.println("fu ...."+x);
}
}
class Zi extends Fu//Zi继承父类Fu
{
Zi()//子类的无参构造函数
{
//super(); //因为父类中有空参数的构造函数,所以super();是可以不用写的
//super(4);//调用父类的有参构造函数,并传递一个数字4
System.out.println("zi run");
}
Zi(int x)
{
this();//子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。
//super();
//super(3);
System.out.println("zi..."+x);
}
}
class ExtendsDemo4
{
public static void main(String[] args)
{
Zi z = new Zi(0);
System.out.println(z.num);
}
}
打印的结果为:
fu run
zi run
zi...0
60
5,final
final : 最终。作为一个修饰符,
1),可以修饰类,函数,变量。
2),被final修饰的类不可以被继承。为了避免被继承,被子类复写功能。
3),被final修饰的方法不可以被复写。
4),被final修饰的变量是一个常量只能赋值一次,既可以修饰成员变量,又可以修饰局部变量。
当在描述事物时,一些数据的出现值是固定的,那么这时为了增强阅读性,都给这些值起个名字。方便于阅读。
而这个值不需要改变,所以加上final修饰。作为常量:常量的书写规范所有字母都大写,如果由多个单词组成。
单词间通过_连接。
5),内部类定义在类中的局部位置上是,只能访问该局部被final修饰的局部变量。
6,抽象类
抽象:看不懂。
抽象类的特点:
抽象类的特点:
1),抽象方法一定在抽象类中。
2),抽象方法和抽象类都必须被abstract关键字修饰。
3),抽象类不可以用new创建对象。因为调用抽象方法没意义。
4),抽象类中的抽象方法要被使用,必须由子类复写起所有的抽象方法后,建立子类对象调用。
如果子类只覆盖了部分抽象方法,那么该子类还是一个抽象类。
抽象类和一般类没有太大的不同。
该如何描述事物,就如何描述事物,只不过,该事物出现了一些看不懂的东西。这些不确定的部分,也是该事物的功能,需要明确出现。但是无法定义主体。通过抽象方法来表示。
抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法。
抽象类不可以实例化。
特殊:抽象类中可以不定义抽象方法,这样做仅仅是不让该类建立对象。
抽象类中是否有构造函数?
有,抽象类是一个父类,要给子类提供实例的初始化。
8,接口
class用于定义类
interface 用于定义接口。
初期理解,可以认为是一个特殊的抽象类,当抽象类中的方法都是抽象的,那么该类可以通过接口的形式来表示。
接口的特点:
接口定义时,格式特点:
1),接口中常见定义:常量,抽象方法。
2),接口中的成员都有固定修饰符。
常量:public static final
方法:public abstract
记住:接口中的成员都是public的。
注意:接口:是不可以创建对象的,因为有抽象方法。需要被子类实现,子类对接口中的抽象方法全都覆盖后,子类才可以实例化。否则子类是一个抽象类。
接口可以被类多实现,也是对多继承不支持的转换形式。java支持多实现。也只有在接口与接口之间才存在多继承。
比如下面的代码:
interface A//A接口
{
void methodA();
}
interface B //B接口
{
void methodB();
}
interface C extends B,A //c继承A和B接口
{
void methodC();
}
class D implements C //D实现C接口
{//那么D中必须复写ABC中的抽象方法,否则还是个抽象类不能实例化
public void methodA(){}
public void methodC(){}
public void methodB(){}
}
接口与抽象类:
共性:都是不断抽取出来的抽象的概念
区别1:抽象类体现继承关系,一个类只能单继承,接口体现实现关系,一个类可以多实现
区别2:抽象类是继承,是 "isa "关系,接口是实现,是 "like a"关系
区别3:抽象类中可以定义非抽象方法,供子类直接使用,接口的方法都是抽象,接口中的成员都有固定修饰符
多态:可以理解为事物存在的多种体现形态。
多态的体现:父类的引用指向了自己的子类对象。父类的引用也可以接收自己的子类对象。
多态的前提:必须是类与类之间有关系。要么继承,要么实现。通常还有一个前提:存在覆盖。
多态的好处:多态的出现大大的提高程序的扩展性。
多态的弊端:虽然提高了扩展性,但是只能使用父类的引用访问父类中的成员。
在多态中成员函数的特点:
在编译时期:参阅引用型变量所属的类中是否有调用的方法。如果有,编译通过,如果没有编译失败。
在运行时期:参阅对象所属的类中是否有调用的方法。
简单总结就是:成员函数在多态调用时,编译看左边,运行看右边。
在多态中,成员变量的特点:
无论编译和运行,都参考左边(引用型变量所属的类)。
在多态中,静态成员函数的特点:
无论编译和运行,都参考做左边。
比如Fu f =new Zi();这是父类的引用指向了子类的对象
Animal a = new Cat();这是类型提升,向上转型。
Cat c =(Cat)a;强制将父类的引用转成子类类型,向下转型。
注意:千万不要出现这样的操作,就是将父类对象转成子类类型。Animal a = new Animal(); Cat c = (Cat)a;
我们能转换的是父类引用指向了自己的子类对象时,该引用可以被提升,也可以被强制转换。
多态自始至终都是子类对象在坐着变化。
四,异常
异常:就是程序在运行时出现不正常情况。
异常由来:问题也是现实生活中一个具体的事物,也可以通过java的类的形式进行描述。并封装成对象。
其实就是java对不正常情况进行描述后的对象体现。对于问题的划分:两种:一种是严重的问题,一种非严重的问题。对于严重的,java通过Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。对与非严重的,java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。无论Error或者Exception都具有一些共性内容。比如:不正常情况的信息,引发原因等。
异常的处理:java 提供了特有的语句进行处理。
try
{
需要被检测的代码;
}
catch(异常类 变量)
{
处理异常的代码;(处理方式)
}
finally
{
一定会执行的语句;
}
对捕获到的异常对象进行常见方法操作。String getMessage():获取异常信息。
比如下面的代码:
class Demo
{
int div(int a,int b)throws Exception//在功能上通过throws的关键字声明了该功能有可能会出现问题。
{
return a/b;
}
}
class ExceptionDemo
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x = d.div(4,1);
System.out.println("x="+x);
}
catch (Exception e)//Exception e = new ArithmeticException();
{
System.out.println("除零啦");
System.out.println(e.getMessage());// / by zero;
System.out.println(e.toString());// 异常名称 : 异常信息。
e.printStackTrace();//异常名称,异常信息,异常出现的位置。
//其实jvm默认的异常处理机制,就是在调用printStackTrace方法。
//打印异常的堆栈的跟踪信息。
}
System.out.println("over");
}
}
上面代码中在函数上进行异常的声明,便于提高安全性,让调用者进行处理。不处理编译失败。、
对多异常的处理。
1,声明异常时,建议声明更为具体的异常。这样处理的可以更具体。
2,对方声明几个异常,就对应有几个catch块。不要定义多余的catch块。如果多个catch块中的异常出现继承关系,父类异常catch块放在最下面。
建议:在进行catch处理时,catch中一定要定义具体处理方式。不要简单定义一句 e.printStackTrace(),
也不要简单的就书写一条输出语句。
自定义异常:
因为项目中会出现特有的问题,而这些问题并未被java所描述并封装对象。所以对于这些特有的问题可以按照java的对问题封装的思想。将特有的问题。进行自定义的异常封装。
当在函数内部出现了throw抛出异常对象,那么就必须要给对应的处理动作。要么在内部try catch处理。要么在函数上声明让调用者处理。一般情况在,函数内出现异常,函数上需要声明。
如何定义异常信息呢?
因为父类中已经把异常信息的操作都完成了。所以子类只要在构造时,将异常信息传递给父类通过super语句。
那么就可以直接通过getMessage方法获取自定义的异常信息。
自定义异常:
必须是自定义类继承Exception。
继承Exception原因:
异常体系有一个特点:因为异常类和异常对象都被抛出。他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。只有这个体系中的类和对象才可以被throws和throw操作。
throws和throw的区别
throws使用在函数上。throw使用在函数内。throws后面跟的异常类。可以跟多个。用逗号隔开。throw后跟的是异常对象。
Exceptoin中有一个特殊的子类异常RuntimeException 运行时异常。如果在函数内容抛出该异常,函数上可以不用声明,编译一样通过。如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过;之所以不用在函数声明,是因为不需要让调用者处理。当该异常发生,希望程序停止。因为在运行时,出现了无法继续运算的情况,希望停止程序后,对代码进行修正。自定义异常时:如果该异常的发生,无法在继续进行运算,就让自定义异常继承RuntimeException。
对于异常分两种:
1,编译时被检测的异常。
2,编译时不被检测的异常(运行时异常。RuntimeException以及其子类)
finally代码块:定义一定执行的代码。通常用于关闭资源。记住一点:catch是用于处理异常。如果没有catch就代表异常没有被处理过,如果该异常是检测时异常。那么必须声明。
异常在子父类覆盖中的体现;
1,子类在覆盖父类时,如果父类的方法抛出异常,那么子类的覆盖方法,只能抛出父类的异常或者该异常的子类。
2,如果父类方法抛出多个异常,那么子类在覆盖该方法时,只能抛出父类异常的子集。
3,如果父类或者接口的方法中没有异常抛出,那么子类在覆盖方法时,也不可以抛出异常。
如果子类方法发生了异常。就必须要进行try处理。绝对不能抛。
总结:
异常:
是什么?是对问题的描述。将问题进行对象的封装。
------------
异常体系:
Throwable
|--Error
|--Exception
|--RuntimeException
异常体系的特点:异常体系中的所有类以及建立的对象都具备可抛性。
也就是说可以被throw和throws关键字所操作。
只有异常体系具备这个特点。
--------------
throw和throws的用法:
throw定义在函数内,用于抛出异常对象。
throws定义在函数上,用于抛出异常类,可以抛出多个用逗号隔开。
当函数内容有throw抛出异常对象,并未进行try处理。必须要在函数上声明,否则编译失败。
注意,RuntimeException除外。也就说,函数内如果抛出的RuntimeExcpetion异常,函数上可以不用声明。
--------------
如果函数声明了异常,调用者需要进行处理。处理方法可以throws可以try。
异常有两种:
编译时被检测异常
该异常在编译时,如果没有处理(没有抛也没有try),编译失败。
该异常被标识,代表这可以被处理。
运行时异常(编译时不检测)
在编译时,不需要处理,编译器不检查。
该异常的发生,建议不处理,让程序停止。需要对代码进行修正。
--------------
异常处理语句:
try
{
需要被检测的代码;
}
catch ()
{
处理异常的代码;
}
finally
{
一定会执行的代码;
}
有三个结合格式:
1. try
{
}
catch ()
{
}
2. try
{
}
finally
{
}
3. try
{
}
catch ()
{
}
finally
{
}
注意:
1,finally中定义的通常是 关闭资源代码。因为资源必须释放。
2,finally只有一种情况不会执行。当执行到System.exit(0);fianlly不会执行。
--------------
自定义异常:
定义类继承Exception或者RuntimeException
1,为了让该自定义类具备可抛性。
2,让该类具备操作异常的共性方法。
当要定义自定义异常的信息时,可以使用父类已经定义好的功能。
异常异常信息传递给父类的构造函数。
class MyException extends Exception
{
MyException(String message)
{
super(message);
}
}
自定义异常:按照java的面向对象思想,将程序中出现的特有问题进行封装。
--------------
异常的好处:
1,将问题进行封装。
2,将正常流程代码和问题处理代码相分离,方便于阅读。
异常的处理原则:
1,处理方式有两种:try 或者 throws。
2,调用到抛出异常的功能时,抛出几个,就处理几个。
一个try对应多个catch。
3,多个catch,父类的catch放到最下面。
4,catch内,需要定义针对性的处理方式。不要简单的定义printStackTrace,输出语句。
也不要不写。
当捕获到的异常,本功能处理不了时,可以继续在catch中抛出。
try
{
throw new AException();
}
catch (AException e)
{
throw e;
}
如果该异常处理不了,但并不属于该功能出现的异常。
可以将异常转换后,在抛出和该功能相关的异常。
或者异常可以处理,当需要将异常产生的和本功能相关的问题提供出去,当调用者知道。并处理。也可以将捕获异常处理后,转换新的异常。
try
{
throw new AException();
}
catch (AException e)
{
// 对AException处理。
throw new BException();
}
比如,汇款的例子。
异常的注意事项:
在子父类覆盖时:
1,子类抛出的异常必须是父类的异常的子类或者子集。
2,如果父类或者接口没有异常抛出时,子类覆盖出现异常,只能try不能抛。
五,内部类
内部类的访问规则:
1,内部类可以直接访问外部类中的成员,包括私有。之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,格式 外部类名.this
2,外部类要访问内部类,必须建立内部类对象。
访问格式:
1,当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中。可以直接建立内部类对象。
格式
外部类名.内部类名 变量名 = 外部类对象.内部类对象;
Outer.Inner in = new Outer().new Inner();
2,当内部类在成员位置上,就可以被成员修饰符所修饰。
比如,private:将内部类在外部类中进行封装。static:内部类就具备static的特性。当内部类被static修饰后,只能直接访问外部类中的static成员。出现了访问局限。
在外部其他类中,如何直接访问static内部类的非静态成员呢?
new Outer.Inner().function();
在外部其他类中,如何直接访问static内部类的静态成员呢?
outer.Inner.function();
注意:当内部类中定义了静态成员,该内部类必须是static的。当外部类中的静态方法访问内部类时,内部类也必须是static的。
当描述事物时,事物的内部还有事物,该事物用内部类来描述。
因为内部事物在使用外部事物的内容。
内部类定义在局部时,
1,不可以被成员修饰符修饰
2,可以直接访问外部类中的成员,因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
比如:
class Outer
{
int x = 3;//成员变量
void method(final int a)
{
final int y = 4;//局部变量,但是被final修饰,内部类可以访问
class Inner //Inner类被定义在了局部
{
void function()
{
System.out.println(y);
}
}
new Inner().function();
}
}
class InnerClassDemo3
{
public static void main(String[] args)
{
Outer out = new Outer();
out.method(7);
out.method(8);
}
}
匿名内部类:
1,匿名内部类其实就是内部类的简写格式。
2,定义匿名内部类的前提:内部类必须是继承一个类或者实现接口。
3,匿名内部类的格式: new 父类或者接口(){定义子类的内容}
4,其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。 可以理解为带内容的对象。
5,匿名内部类中定义的方法最好不要超过3个。
比如:
interface Inter
{
void method();
}
class Test
{
//补足代码。通过匿名内部类。
/*
static class Inner implements Inter
{
public void method()
{
System.out.println("method run");
}
}
*/
static Inter function()
{
return new Inter()
{
public void method()
{
System.out.println("method run");
}
};
}
}
class InnerClassTest
{
public static void main(String[] args)
{
//Test.function():Test类中有一个静态的方法function。
//.method():function这个方法运算后的结果是一个对象。而且是一个Inter类型的对象。
//因为只有是Inter类型的对象,才可以调用method方法。
Test.function().method();
}
}