------- android培训、java培训、期待与您交流! ----------
面向对象
把功能定义为对象的属性。。。。毕老师买电脑、软件公司、。。一切皆对象,万物皆对象;名词提炼法
面向对象:封装;继承;多态;
以后的开发其实就是找对象用,没有对象就创建一个对象
找对象,建立对象,维护对象
类和对象的关系
类就是对现实生活中事物的描述;对象就是这类事物,实实在在存在的个体;
映射到java中,描述就是class定义的类。
具体对象就是对应java在堆内存中用new建立的实体
成员变量,在函数里的是局部变量,成员变量作用于整个类中,局部变量作用于函数中或者语句中,成员变量在堆内存中,因为对象的存在,才在内存中存在,而局部变量存在于栈内存中
封装
是指隐藏对象的属性和实现细节,仅对外提供公共访问方式
好处:将变化隔离;便于使用;提高重用性;提高安全性;
原则:将不需要对外提供的内容都隐藏起来;
把属性都隐藏,提供公共方法对其访问
private:私有,权限修饰符,用于修饰类中成员(成员变量,成员函数),私有只在本类中有效
将成员私有后,类外即使建立对象也不能直接访问,需要在该类中提供对应的访问方式
注意:私有仅仅是封装的一种表现形式
之所以对外提供访问方式,就是因为可以在访问方式中加入逻辑判断语句,对访问的数据进行操作,提高代码的健壮性
构造函数 主要用于给对象初始化,对象一建立就会调用与之对应的构造函数;当一个类中没有定义构造函数,系统会默认给该类加入一个空参数的构造函数;当在类中有了自己定义的构造函数时,则没有了默认的构造函数
1.函数名与类名相同;2.不用定义返回值类型的;3.不可以写return;
构造函数是在对象一建立就运行,给对象初始化,而一般方法是对象调用才执行,是给对象添加对象具备的功能;一个对象建立,构造函数只运行一次,而一般函数可以被该对象多次调用
多个构造函数是以重载的形式存在的
构造代码块--作用:给对象初始化;对象一建立就运行,而且优先于构造函数执行。 构造代码块是给所有对象进行统一初始化,而构造函数是给对应的对象初始化,构造代码块定义的是不同对象的的共性初始化内容。
this关键字 是为了区分局部变量和成员变量重名的情况
this代表本类的对象,this代表它所在函数所述对象的引用,简单说,哪个对象在调用this所在的函数,this就代表哪个对象;当定义类中功能时,该函数内部要用到调用该函数的对象时,这时用this来表示这个对象,但凡本类功能内部使用了本类对象,都用this
this可以用于构造函数之间互相调用,而且只能用this
this语句只能定义在构造函数的第一行,因为初始化要先执行
Person(String name)
{
this.name=name;
}
Person(String name,int age)
{
//this.name = name;
this(name);//这里的this是在调用上面的构造函数
this.age = age;
}
static关键字
static 是一个修饰符,用于修饰成员(成员变量,成员函数),修饰的变量
就不存在与堆内存当中了,每个对象就都能访问到,而不是在每个对象中再单独创建
当成员被静态修饰后,就多了一个调用方式,除了可以被对象调用外,还可
以直接被类名调用 --类名.静态成员
静态变量会被存在内存的方法区(共享区/数据区)
static的特点
1.随着类的加载而加载
也就是说:静态会随着类的消失而消失,它的生命周期最长
2.优先于对象存在
静态是先存在的,对象是后存在的
3.被所有对象所共享
4.可以直接被类名所调用
实例变量和类变量的区别
1.存放位置。类变量随着类的加载而存在于方法区中,实例变量随着对象的建立而
存在于堆内存中
2.生命周期。类变量生命周期最长,随着类的消失而消失,实例变量生命周期随着对象的消失而消失
静态使用注意事项
1.静态方法只能访问静态成员,非静态方法可以既可以访问静态 也可以访问非静态
2.静态方法中不可以定义this,super关键字,因为静态优先于对象存在,所以静态方法中不可以出现this
3.主函数是静态的
静态有利有弊:对对象的共享数据进行单独空间的存储,节省空间,没有必要每一个对象都存在一份,可以直接被类名调用
弊端:生命周期过长,访问出现局限性(静态虽好,只能访问静态)
关于主函数
主函数是一个特殊的函数,作为程序的入口,可以被jvm调用
public static void main(String[] args)
public:代表着该函数有最大的访问权限。
static:代表着主函数随着类的加载就已经存在了
void:主函数没有具体的返回值
main:不是关键字,但是一个特殊的单词,可以被jvm识别
(String[] args):函数的参数,参数类型是一个数组,该数组中的元素是字符串,即字符串类型的数组
主函数是固定格式的,jvm识别
jvm在调用主函数时,传入的是new String[0]
静态的一个重要应用是工具类
每一个应用程序都有共性的功能,可以将这些功能抽取,独立封装,一边复用。这时就可以建立一个专门放功能方法的类,不需要独立运行,可以将其放在一个独立的java文件里,当所调用的函数编译时,会将该java文件先进行编译,生成class文件,从而实现其功能。
虽然可以通过建立工具类的对象使用这些工具方法,但是我们会发现,在工具类里并没有特有的数据,而对象是用来封装数据的,其次操作数组的每一个方法都没有用到工具类里对象中的特有数据,这时为了使程序更加严谨,我们可以将工具类里的方法都定义成static的,直接通过类名调用即可,而不用再创建对象。
将方法都静态后,可以便于使用,但是该类还是可以被其他程序建立对象,为了更加严谨,强制让该类不能创建对象,可以把构造函数也私有化
封装完以后就可以将编译生成的class文件给别人使用了,其他人只要将该文件设置到classpath路径下,就可以使用该类工具了,但是其他人并不知道该类定义了多少方法,对如何使用也不清楚,因为没有说明书。所以要制作说明书
java的说明书通过javadoc文档注释来完成
可以通过/** */来分别对工具类中的各个方法进行说明,而且可以对该工具类的版本、作者等信息进行标识;然后在dos页面下通过调用javadoc指令自动生成该工具类的帮助文档,以网页的形式
静态代码块
格式:
static
{
静态代码块中的执行语句;
}
特点:随着类的加载而执行,只执行一次,用于给类进行初始化的,并优先于主函数执行。但凡用到了类中的内容,就会将类加载,就要执行静态代码块
一个非匿名对象的创建过程
1.因为new用到了class文件,所以会先找到该class文件并加载到内存中
2.如果该类中有static代码块,则执行该类中的static代码块,,给该class类进行初始化
3.在堆内存中开辟空间,分配内存地址
4.在堆内存中建立对象的特有属性,并进行默认初始化
5.对属性进行显示初始化
6.对对象进行构造代码块初始化
7.对对象进行对应的构造函数初始化
8.将内存地址给栈内存中的变量
一个类中默认会有一个空参数的构造函数
这个默认的构造函数的权限和所属的类一致
如果类被public修饰,那么默认的构造函数也带public修饰符
如果类没有被public修饰那么默认的构造函数也没有public修饰
即默认构造函数的权限是随着类的变化而变化的
设计模式:解决某一类问题最行之有效的方法
java中有23中设计模式
单例设计模式:解决一个类在内存中只存在一个对象
想要保证对象唯一
1.禁止其他程序建立该类的对象
2.但为了让其他程序能够访问到该累的对象,只好在本类中自定义一个对象
3.为了方便其他程序对自定义对象的访问,可以对外提供一些访问方法
对于编写代码来说就是
1.将构造函数私有化
2.在类中定义静态的私有的本类对象
3.提供一个方法可以获取该对象
对于事物该怎么描述还怎么描述
当需要将该事物的对象保证在内存中唯一时,就将以上三步加上即可
class Single
{
private int num;
public void setNum(int num)
{
this.num = num;
}
public int getNum()
{
return num;
}
private Single(){} //将构造函数私有化
private static Single s = new Single(); //创建类中的对象,需是静态的私有的
public static Single getInstance() //获取该对象的方法,类型是Single的静态的
{
return s;
}
}
class SingleDemo
{
public static void main(String[] args)
{
Single ss = Single.getInstance();
Single sss = Single.getInstance();
ss.setNum(23);
System.out.println(sss.getNum());//这时ss和sss指向的是同一个对象,即Single类中的对象s
}
}
//单模式的另一种写法是:
/*
class Single
{
private static Single s =null;
private Single(){}
public static Single getInstance()
{
if(s==null)
s=new Single();
return s;
}
}
上面那种方法是先初始化对象,称为饿汉式,而这种方法是方法被调用时才初始化对象,
也叫做对象的延时加载,称为懒汉式
饿汉式只要类一加载,就已经在堆内存中创建好对象,而懒汉式在类进内存时,对象还没有
存在,只有调用了getInstance方法时,才建立对象
定义单例模式时一般使用饿汉式
继承
1.提高了代码的复用性
2.让类与类之间产生了关系,有了这个关系,才有了多
态的特性
但要注意不能为了获取其他类的功能,简化代码而继承,
必须是类与类之间有所属关系才可以继承。所属关系
在java语言中,java只支持单继承,不支持多继承
因为多继承容易带来安全隐患;当多个父类中定义了相同功能,
但功能内容不同时子类对象不确定要用哪个。
但是java保留了这种机制,并用另一种体现形式来表示,即多实现
java支持多层继承,也就是一个继承体系
想要使用体系,先查阅体系父类的描述,因为父类中定义的是该体系
中共性功能。通过了解共性功能,就可以知道该体系的基本功能,这样
这个体系已经可以基本使用了。
那么在具体调用时,要创建最子类的对象,这是因为有可能父类不能创建对象
(抽象类),另外创建子类对象可以使用更多的功能,包括基本的和特有的
即查阅父类功能,创建子类对象使用功能
子父类出现后,类成员的特点
1.变量 如果子类中出现非私有的同名成员变量时,子类要访问本类中的变量
用this,子类要访问父类中的同名变量,用super
super的使用和this的使用几乎一致,this代表子类对象的引用,super
代表父类对象的引用
2.子父类中的函数
当子类出现和父类一模一样的函数时,子类对象调用该函数,会运行子
类函数的内容,如同父类的函数被覆盖一样,这就是函数的另一个特性:
重写(覆盖)
当子类继承父类,沿袭了父类的功能到子类中,但是子类该功能的内容
和父类不一致,这时没有必要定义新功能,而是使用覆盖特性,保留父
类的功能定义,并重写功能内容
注意:
1.子类覆盖父类,必须保证子类权限大于等于父类权限,才可以覆盖,否
则失效;
2.静态只能覆盖静态
重载只看同名函数的参数列表,但重写子父类方法要一模一样
3.子父类中的构造函数
在对子类对象进行初始化时,父类的构造函数也会运行,那是因为子类的
构造函数默认第一行有一条隐藏的语句super();会访问父类中空参数的
构造函数,。而且子类中所有的构造函数默认第一行都是super()。
子类必须访问父类中的构造函数,是因为父类中的数据子类可以直接获取,
所以子类对象在建立时需要先查看父类是如何对这些数据初始化的,所以
子类在对对象初始化时,要先访问以下父类中的构造函数。如果要访问父类
中指定的构造函数,可以通过手动super语句来指定
注意:super语句一定定义在子类构造函数的第一行。
子类的实例化过程
子类的所有的构造函数默认都会访问父类中空参数的构造函数,因为子类每
个构造函数内的第一行都有一句隐式的super();
当父类中没有空参数的构造函数,子类必须手动通过super语句形式来指定
要访问父类中的构造函数;
当然,子类的构造函数第一行也可以手动指定this语句来访问本类中的构造
函数,子类中至少会有一个构造函数会访问父类中的构造函数
final关键字 作为一个修饰符
1.可以修饰类、函数、变量
2.被final修饰的类不可以被继承,为了避免被继承被子类复写功能
3.被final修饰的方法不能被复写
4.被final修饰的变量是一个常量,只能赋值一次,既可以修饰成员
变量,也可以修饰局部变量
当在描述事物时,一些数据的出现是固定的,那么为了增强阅读性
都给这个值起个名字,方便与阅读,而这个值不需要改变,就用
final修饰作为常量,常量的书写规范所有字母都大写,如果由多
个单词组成,单词间通过——链接
5.内部类定义在类中的局部位置上时,只能访问该局部被final修
饰的局部变量
当多个类中出现了相同功能,但功能主题不同,这时可以进行向上抽取,只抽取
功能定义,不抽取功能主题
抽象类特点:
1.抽象方法一定定义在抽象类中。
2.抽象方法和抽象类都必须被abstract关键字修饰
3.抽象类不可以被new创建对象,因为调用抽象方法没意义
4.抽象类中的抽象方法要被使用,必须有子类复写其所有的抽象方法,建立子类对象调用
如果子类只覆盖了部分抽象方法,那么该子类还是一个抽象类
抽象类和一般类没有太大的不同,该如何描述事物就如何描述事物,只不过该事物中出现了
一些看不懂的东西,这些不确定的部分,也是该事物的功能,需要明确出来,但无法明确
主题,通过抽象方法来表示
抽象类比一般类多了抽象函数,就是在类中可以定义抽象方法
抽象类不可以被实例化
抽象类中可以不定义抽象方法,这样做仅仅是不让该类创建对象
接口:可以简单的理解为是一个特殊的抽象类,当抽象类中的方法都是抽
象的,那么该类可以通过接口的形式来表示
class用于定义类,interface用于定义接口
接口在定义时,格式特点:
1.接口中常见定义:常量,抽象方法
2.接口中的成员都有固定修饰符;
常量:public static final
方法:public abstract
即接口中的成员都是public的
接口是不可以创建对象的,因为有抽象方法,需要被子类实现,子类对接
口中的抽象方法全部覆盖后,子类才可以实例化,否则子类也是个抽象类
接口可以被类多实现,也是对不支持多继承的转换形式,java支持多实现
接口是对外暴露的规则
接口是程序的功能扩展
接口可以用来多实现
接口与类之间是实现关系,而且类可以继承一个类的同时实现多个接口
接口与接口之间可以有继承关系
Object是所有对象的直接或者间接父类。该类中定义的肯定是所有对象都具备的功能
Object类中已经提供了对对象是否相同的比较方法。
如果自定义类中也有比较相同的功能,没必要重新定义,只要沿袭父类中的功能,建
立自己特有的比较内容即可,即覆盖
匿名内部类
1.匿名内部类其实就是内部类的简写格式
2.定义内部类的前提:内部类必须是继承一个类或者实现接口
3.匿名内部类的格式:new 父类或者接口(){定义子类的内容}
4.其实匿名内部类就是一个匿名子类对象,而且这个对象内容较大,即带内容的对象
5.匿名内部类中定义的方法最好不要超过三个
内部类定义在局部时
1.不可以被成员修饰符修饰
2.可以直接访问外部类中的的成员,因为还持有外部类中的引用
但是不可以访问它所在的局部变量,只能访问final修饰的局部变量
内部类的访问规则:
1.内部类可以直接访问外部类中的成员,包括私有
之所以可以直接访问外部类中的成员,是因为内部类总持有了一个
外部类的引用,格式:外部类名.this
2.外部类要访问内部类,必须建立内部对象
访问格式:
1.当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中
直接建立内部类对象,格式:外部类.内部类名变量名 = 外部类对象.内部类
Outer.Inner in = new Outer().new Inner();
2.当内部类在成员位置上,就可以被成员修饰符修饰。
比如,private:将内部类在外部类中进行封装
static:内部类就具备static的特性
当内部类被静态修饰后,只能直接访问外部类中的静态成员了,出现了访问局限
在外部其他类中,访问静态内部类的非静态成员
new Outer.Inner().function();
在外部其他类中,访问静态内部类的静态成员
Outer.Inner.function();
注意当内部类中定义了静态成员,该内部类必须是静态成员
当外部类的静态方法访问内部类时,内部类也必须是静态的
多态:可以理解为事物的多种体现形式
1.多态的体现
父类的引用指向了自己的子类对象,父类的引用也可以接受自己的子类对象
2.多态的前提
必须是类与类之间有关系,要么继承,要么实现,通常还有个前提,存在覆盖
3.多态的优势
多态的出现提高了程序的扩展性
4.多态的弊端
只能使用父类的引用访问父类中的成员
5.多态的应用
6.多态在代码中的特点(多态使用的注意事项)
在多态中成员函数的特点:
在编译时期,参阅引用型变量所属的类中是否有调用的方法,如果有,编译通过
如果没有,编译失败
在运行时期,参阅对象所属的类中是否有调用的方法
简单总结就是,成员函数在多态调用时,编译看左边,运行看右边
在多态中,成员变量的特点:无论编译和运行都参考左边,即引用型变量所属的类
在多态中,静态成员函数的特点:无论编译和运行都参考左边
异常:
是对问题的描述,将问题进行对象的封装
异常体系
Throwable
Error
Exception
RuntimeException
异常体系的特点:异常体系中的所有类以及建立的对象都具备可抛性。
也就是说可以被throw和throws关键字操作,只有异常体系具备这个特点
throw和throws的用法:
throw定义在函数内,用于抛出异常对象
throws定义在函数上,用于抛出异常类,可以抛出多个用逗号隔开
当函数内容有throw抛出异常对象,并未进行try处理,必须要在函数上声明,否则编译失败
注意,RuntimeException除外,也就是说,函数内如果抛出的RuntimeException异常,函数上
可以不用声明
如果函数声明了异常,调用者需要进行处理,处理方法可以throws或者try
异常有两种
编译时被检测异常
该异常在编译时,如果没有处理(没有抛出也没有try),编译失败
该异常被标识,代表可以被处理
运行时异常(编译时不检测)
在编译时,不需要处理,编译器不检查
该异常的发生,建议不处理,让程序停止,需要对代码进行修正
异常处理语句:
try
{
需要被检测的代码;
}
catch()
{
处理异常的代码;
}
finally
{
一定会执行的代码;
}
有三种结合格式
try
{}
catch()
{}
try
{}
finally
{}
try
{}
catch()
{}
finally
{}
注意,
1.finally中定义的通常是关闭资源代码,因为资源必须释放
2.finally只有一种情况不会执行,当执行到System.exit(0);finally不会执行
自定义异常
定义类继承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.异常:就是程序在运行时出现不正常情况
异常由来:问题也是现实生活中一个具体的事物,也可以通过java的类的形式进行描述
并封装成对象,其实就是java对不正常情况进行描述后的对象体现
问题的划分:一种是严重的问题,一种是非严重的问题
对于严重的,java通过Error类进行描述,对于Error一般不编写针对性的代码对其处理
对于非严重的,java通过Exception进行描述,对于Exception可以使用针对性的处理方式进行处理
Error和Exception都是一些共性内容,比如不正常信息,引发原因等
Throwable
Error
Exception
2.异常的处理
Java提供了体有的语句进行处理
try
{
需要检测的代码
}
catch(异常类变量)
{
处理异常的代码;(处理方式)
}
finally
{
一定会执行的语句;
}
3.对捕获到的异常对象进行常见方法操作
String getMessage();获取异常信息
在函数上声明异常,便于提高安全性,让调用处进行处理,不处理编译失败
对多异常的处理
1.声明异常时建议声明和更为具体的异常,这样处理的更具体
2.对方声明几个异常,就对应几个catch块,不要定义多个多余的catch块
如果多个catch块中的异常出现继承关系,父类异常catch块放在最下面
建议在进行catch处理时,catch中一定要定义具体处理方式
不要简单一句e.printStackTrace(),
也不要就简单的输出一条输出语句。
因为在项目中会出现特有的问题,而这些问题并未被java所描述并封装对象
所以对这些特有的问题可以按照java的对问题封装的思想,将特有的问题,进行
进行自定义的异常封装
当在函数内部出现了throw抛出异常对象,那么就必须给出对应的处理动作
要么在内部try catch处理,要么在函数上声明让调用者处理
一般情况下,函数内出现异常,函数上需要声明。
发现打印的结果中只有异常的名称,没有异常的信息,因为自定义的异常并未定义信息
一位父类已经把异常信息的操作都完成了,所以子类只要在构造时将信息传递给父类通过super
语句,那么就可以直接通过getMessage方法获得异常信息了
自定义异常必须是自定义类继承Exception
继承Exception是因为异常类和异常对象都需要被抛出,他们都具有可抛性,是throwable这个
体系的独有特点,只有这个体系中的类和对象才可以被throw和throws操作
throws和throw的区别
throws使用在函数上,throw使用在函数内
throws后面跟的是异常类,可以跟多个,用逗号隔开;throw后面跟的是异常对象。
//将自定义的问题定义成类,并且要继承Exception
class FushuException extends Exception
{
//private String msg;
FuShuException(String msg)
{
//this.msg = new msg;
super(msg);
}
/*
public String getMessage()
{
return msg;
}
*/
}
class Demo1
{
int div1(int a,int b)throws FuShuException
{
if(b<0)
throw new FuShuException("除数是负数了");//手动通过throw定义一个异常
return a/b;
}
}
class Demo
{
int div(int a,int b)throws ArithmeticException ,ArrayIndexOutOfBoundsException
{ //在功能上通过throws关键字声明了该功能可能出现问题
int[] arr = new int[a];
System.out.println(arr[4]);
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 (ArithmeticException e)//e就相当于:Exception e = new ArithmeticException
{
System.out.println("除数为0了");
System.out.println(e.getMessage());//by zero
System.out.println(e.toString());//异常名称:异常信息
e.printStackTrace();//异常名称:异常信息;异常出现的位置
} //其实jvm默认的异常处理机制就是调用printStackTrace
//打印异常的堆栈的跟踪信息
catch (ArrayIndexOutOfBoundsException e)
{
System.out.println(e.toString());
System.out.println("角标越界啦");
}
//int x = d.div(4,0);//除数是0 ,出现问题
//System.out.println("x="+x);
System.out.println("over");
}
}
异常在子父类覆盖中的体现:
1.子类在覆盖父类时,如果父类的方法抛出异常,那么子类的覆盖方法只能抛出父类的
异常或该异常的子类
2.如果父类抛出多个异常,那么子类在覆盖该方法时,只能抛出父类异常的子集
3.如果父类或者接口的方法中没有异常抛出,那么子类在覆盖方法时也不可以抛出异常
如果子类方法发生异常,就必须进行try处理,绝对不能抛出
------- android培训、java培训、期待与您交流! ----------