1. 内部类类别:
1.1成员内部类:在一个类的成员位置定义另外一个类就称为成员内部类。
1.1.1成员内部类的访问方式:
方式1:在外部类内提供一个方法创建内部类的对象进行访问。
方式2:在其他类创建内部类的对象进行访问。创建的格式:外部类.内部类 变量名=new 外部类()
注意:如果是静态内部类在其他类的创建对象方式:外部类.内部类 变量名=new 外部类.内部类();
1.1.2成员内部类要注意的事项:
①成员内部类可以直接访问外部类成员。
②如果成员内部类与外部类存在同名的成员,在内部类中默认访问内部类的成员
成员通过“外部类.this.成员“指定访问外部类的成员。
③如果成员内部类出现了静态的成员,那么该成员内部类也必须使用static修饰。
④如果成员内部类是私有的,那么创建内部类的对象就只能在外部类提供方法创建。
1.2局部内部类:在一个类的方法内部定义另外一个类,另外一个类就称为局部内部类。
局部内部类要注意:如果局部内部类访问了局部变量,那么该变量需要使用fianl修饰。(原因:生命周期不同。)
匿名内部类:没有类名的类。
匿名内部类的好处:简化书写。
匿名内部类的使用前提:必须存在继承或者实现关系。
匿名内部类的格式:
new 父类(父接口){
匿名内部类的成员;
} ;
2.异常:
2.1异常的体系;
---------------|throwable
-------------------|error(错误)错误一般是由于jvm或者是硬件引发的问题,所以我们一般不会通过代码去处理。
-------------------|exception(异常)异常我们
2.2异常处理方式
2.2.1 方式一:捕获处理
捕获处理的格式
try{
可能发生异常的代码
}catch(捕获的异常类型 变量名){
处理异常的代码
}
捕获处理要注意的细节:
①如果一个try块中出现了异常的代码,经过出来后,那么try-catch块外面的代码可以正常执行。
②如果一个try块中出现了异常的代码,那么在try块中出现异常的代码后面的语句无法执行
③一个try块后面可以跟多个catch块,也就是一个try块可以捕获多种异常的类型,但是捕获的类型必须从小到大进行捕获。
2.2.2方式二:抛出处理(throw throws)
①.如果一个方法内部抛出了一个编译时异常对象,那么该方法必须要声明抛出。
②.如果调用了一个声明抛出编译时异常的方法,那么调用者必须要处理。
③.如果一个方法抛出了一个异常对象,那么该方法也会马上停止(一个方法遇到了throw关键字,那么该方法就会马上停止)
④在一种情况下只能抛出一种异常对象。
Throw关键字是用于方法体之内抛出异常对象的,throws是用于方法声明抛出异常的。
运行时异常都是可以通过程序员的编译习惯来避免。
二.自定义异常类
1.1来由,sun提供的异常类不够,所以需要自定义异常类。
class NoMoneyException extends Exception{
public NoMoneyException(String message){
super(message);
}
class Demo8{
public static void main(String[] args){
try{
eat(5);
}catch(NoMoneyException e){
System.out.println("跟我洗碗一个月!!!");
}
}
public static void eat(int money)throws NoMoneyException{
if(money<10){
throw new NoMoneyException("吃霸王餐");
}
System.out.println("吃上了香喷喷的地沟油");
}
}
异常体系里面的Exception(异常)异常一般都通过代码处理
分运行时异常:如果一个方法内部抛出了一个运行时异常,那么方法上可以声明也可以不声明,调用者可以处理,也可以不处理。
编译时异常:(非运行时异常、受检异常):如果方法内部抛出了一个编译时异常对象,那么方法上就必须要声明,而且调用者必须处理
错误符号有RuntimeException以及其子类
三.Finally块
Finally块的使用前提是必须要存在try块才能使用。
Finally块的代码在任何情况下都会执行,除了jvm退出的情况。
Finally非常适合做资源释放的工作,这样才能保证资源在任何情况下都会被被释放
Try块的三种组合方式:
第一种:比较适合有异常要处理,但没有资源要释放。
try{可能发生异常的代码}catch
(捕获的异常类型 变量名}{
处理异常的代码
}
第二种:比较适用于及有异常要处理,又有资源要释放
try{可能发生异常的代码}catch
(捕获的异常类型 变量名}{
处理异常的代码
}finally{
释放资源的代码
}
第三种:比较适用于内部抛出的是运行时异常,并且有资源要被释放。
try{可能发生异常的代码}
}finally{
释放资源的代码;
}
三.导包语句:java中的包相当于windows文件夹
1.包的作用:
①解决类名重复产生冲突的的问题。
②便于软件版本的发布。
2定义包的格式:
package 包名;
包名命名规范:包名全部小写。
3.包语句要注意的事项:
①package语句必须位于Java文件中的第一个语句。
②如果一个类加上了包语句,那么该类的完整类名就是;包名.类名
③一个Java文件只能有一个包语句
javac -d指定类文件的存放路径 java源文件
javac -d . Demo2.java
4.有了包之后类与类之间的访问:
问题:有了包之后类与类之间的访问每次都必须要写上包名!!!烦
解决方案:sum提供导包语句让我们解决该问题。
导包语句的作用:简化书写。(误区:把一个类导入到内存中)
导包语句的格式:
Import 包名.类名;(导入xxx包中的某个类);
5.导包语句要注意的细节:
①一个java文件中可以出现多句导包语句。
②”*”是导包语句的通配符。可以匹配任何的类名。
③。import aa.*;是不会作用于aa包下面的子包的。
推荐使用:import 包名.类名;因为使用“*”通配符会
6.什么时候使用import语句:
①相互访问的两个类不是在同一个包下面,这时候就需要使用到导包语句。
②java.lang是默认导入的,不需要我们自己导入。
四.访问权限修饰符
1.定义:权限修饰符就是控制 被修饰的成员的范围可见性。
public(公共) protect(受保护的) default (缺省) private(大到小)
同一个类 true true true true
同一个包 true true true false
子父类 true true true false
不同包 true false false false
注意:在不同包下面只有public与protected可以访问,而且protected必须是在继承关系下才能够访问。
五.打jar包 :需要使用jdk的开发工具(jar.exe)
jar文件的作用:①方便用户快速运行一个项目。
②提供工具类给别人使用。
使用格式:
jar cvf jar文件名 class文件或者文件夹
打jar包要注意的事项:
① 一个程序打完了jar之后必须要在清单文件指定入口类: 格式Main-class:包名.类名
② jar包双击运行仅对于图形化界面的程序起作用,对于控制台的程序不起作用。
如果使用jar包里面的类必须要先设置classpath路径。
Jre=jvm+核心类库
六.模板模式:
定义:解决某类事情的步骤有些是固定的,有些是会发生变化的,那么这时候我们为这类事物提供一个模板代码,从而提高效率。
需求:编写一个计算机程序运行时间的模板。
模板模式的步骤:
① 先写出解决该类事情其中个=的一件的解决方案。
② 分析代码,把会发生变化的代码抽取出来独立成一个方法。把该方法独立描述成一个抽象的方法。
③ 使用final修饰模板方法,防止别人重写你的模板方法。
1. 抽象类
描述一类事物的时候,发现确实存在某种行为,但是目前这种行为不具体,这时候应该抽取这种行为的声明,而不去实现这种行为,这时候这种行为我们成为抽象行为,这时候应该使用抽象类。
要注意的细节:
① 如果一个方法没有方法体,那么该方法必须使用abstract修饰。
② 如果一个类函数有抽象方法,那么这个类肯定是一个抽象类或接口。
③ 抽象类不能创建方法,抽象类是含有构造方法的。
④ 抽象类可以存在非抽象方法与抽象方法。
⑤ 抽象类可以不存在抽象方法。
⑥ 非抽象类继承抽象类的时候,必须要把抽象类中所有抽象方法全部实现。
⑦ abstract不能与以下关键字一起使用,static,private,final
2. 接口
接口的定义格式:
Interface 接口名{
成员变量
成员函数….
}
接口的作用:
① 程序的解耦
② 定义约束的规范
③ 拓展功能
接口要注意的细节
① 接口中的成员变量都是常量,默认的修饰符是public static final。
② 接口中的方法全部都是抽象方法,默认的修饰符:public abstract。
③ 接口不能创建对象。
④ 接口是没有构造函数的。
⑤ 非抽象类通过implements实现接口的时候,必须要把接口中所有方法全部实现。
接口与类之间的关系:实现关系
注意:一个类可以实现多个接口。
接口与接口之间的关系:继承关系
注意:一个接口可以继承多个接口。
3. 多态,父类的引用类型变量指向了子类的对象,或者是接口的引用类型变量指向了接口实现类的对象。
要注意的细节
① 多态情况下,如果子父类存在同名的成员变量时,访问的是父类的成员变量。
② 多态情况下,如果子父类存在同名的非静态函数时,访问的是子类的成员变量。
③ 多态情况下,如果子父类存在同名的静态函数时,访问的是父类的成员变量。
④ 多态情况下,不能访问子类特有的成员。
多态的应用:
① 多态用于形参类型的时候,可以接收更多类型的数据。
② 多态用于返回值类型的时候,可以返回更多类型的数据。
二 强制类型转换:
1.来源:由于目前多态情况下不能访问子类特有的成员。
2.如果需要访问子类特有的成员,那么需要进行类型强制转换。
小数据类型----------->大的数据类型 自动类型转换
大数据类型------------>小的数据类型 强制类型转换 小数据类型
变量名=(小数据类型)大数据类型;
3.引用数据类型的转换
小数据类型----------->大的数据类型 自动类型转换
大数据类型------------>小的数据类型 强制类型转换
类型转换最常见的问题;java.lang.ClassCastException。强制类型转换失败。
If(a instanceof Fish)
接口 变量=new 接口实现类的对象
三 内部类
定义:一个类定义在另一个类的内部,那么该类就称作为内部类。
内部类的class文件名:外部类$内部类。便于区分该class文件是属于哪个外部类的
内部类的类别:
1. 成员内部类:
成员内部类的访问方式:
方式一在外部类提供一个方法创建内部类的对象进行访问。
方式二:在其他类直接创建内部类的对象。格式:外部类。内部类 变量名
=new 外部类().new内部类()。
注意:如果是一个静态内部类,那么在其他类创建的格式:
外部类.内部类 变量名=new 外部类.内部类();
内部类的应用场景:我们在描述A事物的时候,发现描述的A事物内部还存在另外一个比较复杂的事物B的时候,而且这个比较复杂事物B还需要访问A事物的属性等数据,那么这时候我们就可以使用内部描述B事物。
2. 局部内部类
在一个类的方法内部定义另外一个类,那么另外一个类就称作为局部内部类。
注意:
如果局部内部类访问了一个局部变量,那么该局部变量必须使用final修饰。
3. 匿名内部类
① 定义:没有类名的类就称为匿名内部类。
② 好处:简化好写。
③ 使用前提:必须存在继承或者实现关系才能使用。
匿名内部类一般用于实参
四Throwable以及错误
异常:
Throwable分为error和exception,exception又分为运行异常和编译时异常 1..throwable常用的方法
tostring() 返回当前对象的完整类名 +病态信息。
Throwable t=new Throwable();
String info = t.tostring();
System.out.println(“tostring:”+info);//java.lang.Throwable 包类+类名=完整类名
getMessage() 返回的是创建Throwable传入的字符串信息。
Throwable t=new Throwable(“头晕,感冒….”);
String message = t.getMessage ();
System.out.println(“tostring:”+info);//java.lang.Throwable
System.out.println(“getMessage:”+message);
printstackTrace() :打印异常的栈信息。
1.1error:错误一般是用于jvm或者是硬件引发的问题
1.2Exception异常 是需要代码去处理
如何区分error与Exception
如果程序出现不正常的信息,如果不正常的信息以error肯定是一个错误,
如果是以Exception结尾,那么肯定就是一个异常。
1.3异常的处理:
方式一:捕获处理。
捕获处理的格式:
try{
可能发生异常的代码;
}catch(捕获的异常类型 变量名)
{处理异常的代码
}
1.3.1捕获处理要注意的细节:
① 如果try-catch块外面的代码可以正常执行。
② 如果try块中出了异常代码,那么在try块中出现异常代码后面的代码是不会执行的。
③ 一个try块后面可以跟多个catc模块的。
1.4方式二:抛出处理。
① 如果一个方法的内部抛出了一个异常对象,那么必须在方法上声明抛出。
② 如果调用了一个声明抛出异常的方法,那么调用者必须处理异常。
③ 如果一个方法内部抛出了一个异常对象,那么throw语句后面的代码都不会再执行了
④ 在一种情况下,只能抛出一种类型异常对象。
1.4.1 throw与throws两个关键字:
② throw关键字是用于方法内部的,throws是用于方法声明上的。
②throw 是用于方法内部抛出一个异常对象的,throws关键字是用于在方法声明上声明抛出异常类型的。
③ Throws关键字后面只能有一个异常对象,throws’后面一次可以声明抛出多种类型的异常