黑马程序员——面向对象(二)---类的继承、多态性、匿名内部类、异常、包、访问控制、命名规范、jar文件
来源:互联网 发布:子域名查询工具 编辑:程序博客网 时间:2024/05/19 05:29
------- android培训、java培训、期待与您交流! ----------
第一部分 类的继承
一.概述
1.通过继承可以简化类的定义 。
2.Java只支持单继承,不允许多重继承。
3.可以有多层继承,即一个类可以继承某一个类的子类,如类B继承了类A,类C又可以继承类B,那么类C也间接继承了类A。
4.子类继承父类所有的成员变量和成员方法,但不继承父类的构造方法。在子类的构造方法中可使用语句super(参数列表) 调用父类的构造方法。
5.如果子类的构造方法中没有显式地调用父类构造方法,也没有使用this关键字调用重载的其它构造方法,则在产生子类的实例对象时,系统默认调用父类无参数的构造方法。
注一:子类的每个构造方法中必须调用父类的一个构造方法
二.子类对象的实例化过程
1.分配成员变量的存储空间并进行默认的初始化,就是用new关键字产生对象后,对类中的成员变量按第三章的表3.1中的对应关系对对象中的成员变量进行初始化赋值。
2.绑定构造方法参数,就是new Person(实际参数列表)中所传递进的参数赋值给构造方法中的形式参数变量。
3.如有this()调用,则调用相应的重载构造方法(被调用的重载构造方法又从步骤2开始执行这些流程),被调用的重载构造方法的执行流程结束后,回到当前构造方法,当前构造方法直接跳转到步骤6执行
4.显式或隐式追溯调用父类的构造方法(一直到Object类为止,Object是所有Java类的最顶层父类,在本章后面部分有详细讲解),父类的构造方法又从步骤2开始对父类执行这些流程,父类的构造方法的执行流程结束后,回到当前构造方法,当前构造方法继续往下执行。
5.进行实例变量的显式初始化操作,也就是执行在定义成员变量时就对其进行赋值的语句,如:
6.执行当前构造方法的方法体中的程序代码
7.图示:
思考:1).为什么super(…)和this(…)调用语句不能同时在一个构造函数中出现?
答:按照上面的流程可知,如果同时定义了super(…)和this(…),当执行第一句时就会跳过第二句,所以写了也是白写。
2).为什么super(…)或this(…)调用语句只能作为构造函数中的第一句出现?
答:按照上面的流程,要先执行super(…)或this(…),再执行代码。若不把super(…)或this(…)放在第一句,与流程相矛盾。
三.覆盖父类的方法(@Override)
1.覆盖方法必须和被覆盖方法具有相同的方法名称、参数列表和返回值类型。
2.如果在子类中想调用父类中的那个被覆盖的方法,我们可以用super.方法的格式。
3.覆盖方法时,不能使用比父类中被覆盖的方法更严格的访问权限。
若父类中为私有成员方法,则子类不能访问,也不能覆盖此方法。
四.final关键字
1.在Java中声明类、属性和方法时,可使用关键字final来修饰。
2.final标记的类不能被继承。
3.final标记的方法不能被子类重写。
4.final标记的变量(成员变量或局部变量)即成为常量,只能赋值一次。
注4:对于final成员变量,可以在定义时进行初始赋值,也可以在构造方法中进行初始赋值,但只能选择其中一处进行初始化。初始化以后都不能再修改了。
5.方法中定义的内置类只能访问该方法内的final类型的局部变量,用final定义的局部变量相当于是一个常量,它的生命周期超出方法运行的生命周期,将一个形参定义成final也是可以的,这就限定了我们在方法中修改形式参数的值。
6.public static final共同标记常量时,这个常量就成了全局的常量。
注6:对于此种变量,只能在定义时进行初始化赋值,或者在静态代码块中进行赋值,二选一。
五.抽象类
java中可以定义一些不含方法体的方法,它的方法体的实现交给该类的子类根据自己的情况去实现,这样的方法就是抽象方法,包含抽象方法的类就叫抽象类。
1.抽象类必须用abstract关键字来修饰;抽象方法也必须用abstract来修饰。
2.抽象类不能被实例化,也就是不能用new关键字去产生对象。
3.抽象方法只需声明,而不需实现。
4.含有抽象方法的类必须被声明为抽象类,抽象类的子类必须覆盖所有的抽象方法后才能被实例化,否则这个子类还是个抽象类,,必须用abstract修饰。
注五:方法的括号后如果跟有大括号,无论大括号内又无语句,这个方法就是实现了的方法;如果括号后没跟大括号,而是‘;’,则此为方法的声明。
六.接口(interface)
如果一个抽象类中的所有方法都是抽象的,我们就可以将这个类用另外一种方式来定义,也就是接口定义。接口是抽象方法和常量值的定义的集合,从本质上讲,接口是一种特殊的抽象类,这种抽象类中只包含常量和方法的定义,而没有变量和方法的实现。
1.接口中的成员都是public访问类型的。接口里的变量默认是用public static final标识的 。
2.我们可以定义一个新的接口用extends关键字去继承一个已有的接口
3.我们也可以定义一个类用implements关键字去实现一个接口中的所有方法,我们还可以去定义一个抽象类用implements关键字去实现一个接口中定义的部分方法。
4.一个类可以继承一个父类的同时,实现一个或多个接口,extends关键字必须位于implemnets关键字之前 。
七.对象的类型转换
1.子类对象可以自动转换成父类
2.父类转换成子类必须使用强制转换。
3.instanceof 操作符可以用它来判断一个实例对象是否属于一个类。
4.Object类及equals方法
注4:如果定义一个类没有显示继承任何类,那么编译器就会隐式的让他继承Object类。
public boolean equals(Object obj) {if (!(obj instanceof Person))return false;Person other = (Person) obj;if (other.name == name && other.age == age)return true;elsereturn false;}
第二部分 面向对象的多态性
1.应用程序不必为每一个派生类(子类)编写功能调用,只需要对抽象基类进行处理即可。这一招叫“以不变应万变”,可以大大提高程序的可复用性。
2.派生类的功能可以被基类的引用变量引用,这叫向后兼容,可以提高程序的可扩充性和可维护性。以前写的程序可以被后来程序调用不足为奇,现在写的程序(如callA方法)能调用以后写的程序(以后编写的一个类A的子类, 如类D)就了不起了。
代码:
interface PCI {void start();void stop();}class NetWorkCard implements PCI {public void start() {System.out.println("Send....");}public void stop() {System.out.println("Stop.....");}}class SoundCard implements PCI {public void start() {System.out.println("du.....du");}public void stop() {System.out.println("sound stop");}}class MainBoard {public void usePCICard(PCI p) {p.start();p.stop();}}public class Assembler {public static void main(String[] args) {MainBoard mb = new MainBoard();NetWorkCard nc = new NetWorkCard();SoundCard sc = new SoundCard();mb.usePCICard(nc);mb.usePCICard(sc);}}
第三部分 匿名内部类
匿名内部类必须是实现了某个接口或继承了某个抽象类、普通类的匿名类。
用匿名内部类实现上述的PCI接口,并调用其中方法的代码:
mb.usePCICard(new PCI() {public void stop() {System.out.println("test start");}public void start() {System.out.println("test stop");}});
第四部分 异常
1.异常定义了程序中遇到的非致命的错误, 而不是编译时的语法错误,如程序要打开一个不存的文件、网络连接中断、操作数越界、装载一个不存在的类等。
2.try,catch语句
注2:实例代码,
public class ExceptionTest {public static void main(String[] args) {new Test().divide(3, 0);System.out.println("ok");}}class Test {public int divide(int x, int y) {int result=0;try {result = x / y;} catch (Exception e) {System.out.println("by zero");return result;}return result;}}
3.throws关键字
throws关键字指出函数内部有可能会抛出异常,所以在调用函数时编译器强制要求进行异常处理。
当main方法也用throws抛出异常时,只会是编译器通过,达不到对异常的实质处理,不建议这么做。
注3:实例代码,
class Test {public int divide(int x, int y) throws Exception{int result = x / y;System.out.println("by zero");return result;}}public class ExceptionTest {public static void main(String[] args) {try {new Test().divide(3, 0);} catch (Exception e) {System.out.println("by zero");e.printStackTrace();}System.out.println("ok");}}
4.自定义异常与Throw关键字
注4:实例代码,
class DivedeByMinusException extends Exception{public DivedeByMinusException(String msg){super(msg);}}class Test {public int divide(int x, int y) throws Exception{if(y<0)throw new DivedeByMinusException("devisor is "+y);int result = x / y;return result;}}public class ExceptionTest {public static void main(String[] args) {try {new Test().divide(3, -2);} catch (Exception e) {//获取传入异常对象时传入的信息System.out.println(e.getMessage());}System.out.println("ok");}}
5.如何对多个异常作出处理
通过throw,try…catch,finally语句实现对多个异常进行的处理.
try…catch会根据异常的类型进入不同的catch语句中。
catch语句的放置顺序很重,不能把父异常类放在子异常类之前,否则子异常的catch永远捕获不到异常。
finally中的代码块无论是否发生异常都会被执行的,即便之前执行的代码中有return语句它也会被执行,除非使用System.exit(0);来强制终止整个程序时finally才不会被执行。
注5:实例代码,
class Test {public int divide(int x, int y) throws ArithmeticException,DivedeByMinusException{if(y<0)throw new DivedeByMinusException("devisor is "+y);int result = x / y;return result;}}public class ExceptionTest {public static void main(String[] args) {try {new Test().divide(3, 0);} catch (ArithmeticException e) {System.out.println("program is running into Arithmetic");e.printStackTrace();}catch (DivedeByMinusException e) {System.out.println("program is running into DiveByMinus");}catch (Exception e) {System.out.println(e.getMessage());}finally{System.out.println("finally");}System.out.println("program is running here.");}}
6.我们可以在一个方法中使用throw,try…catch,finally语句来实现程序的跳转
注6:示例代码,
public void func(int x,int y){try{if(x==0)throw new XxxException("Arithmetic");else throw new YyyException("DivedeByMinus");}catch(XxxException e){//执行代码}catch (YyyException e) {//执行代码}finally{//执行代码}}
7.一个方法被覆盖时,覆盖它的方法必须扔出相同的异常或异常的子类。
8.如果父类扔出多个异常,那么重写(覆盖)方法必须扔出那些异常的一个子集,也就是说不能扔出新的异常。
第五部分 包
1.package语句及应用
package cn.itcast;
Java通过package来提供多重命名空间,防止因为类冲名带来的不便。
若源文件使用了package定义包,class类必须在对应的文件夹之下才可能被找到。
注1:若使用javac -d . xxx.java 来进行编译,则会在当前目录下创建源文件中包名对应的目录结构,并把class文件放置于对应位置下。
在运行java命令时所处的当前目录不能在包名内,必须在包的顶级目录的父目录之下。否则找不到相应包对应的目录和class文件。
综上,只有:
a.源文件中定义了package语句;
b.实际存在与包名对应的目录结构和class文件;
c.classpath中有处于b中的目录结构的父目录中的路径;
d.使用了 java 包名.类名 这种格式的语句;
都具备时才能顺利执行程序。
2.package语句作为Java源文件的第一条语句。如果没有package语句,则为缺省无名包。
在源文件中只能有一条package语句。
3.import语句及应用
import cn.itcast.*;
加入这条语句后,使用此包中的类时,不用再显式的写出包名了,import语句能简化代码的编写。
在引入父包下的所有类时,若父包下存在子包,此时并不后悔把子包中的类也引入进来。因此需要在定义一条import语句来引入子包中的类。
4.dk中常用的包
1>java.lang----包含一些Java语言的核心类,如String、Math、Integer、System和Thread,提供常用功能。
2>java.awt----包含了构成抽象窗口工具集(abstract window toolkits)的多个类,这些类被用来构建和管理应用程序的图形用户界面(GUI)。
3>java.applet----包含applet运行所需的一些类。
4>java.net----包含执行与网络相关的操作的类。
5>java.io----包含能提供多种输入/输出功能的类。
6>java.util----包含一些实用工具类,如定义系统特性、使用与日期日历相关的函数。
第六部分 访问控制
类本身也有访问控制,即在定义类的class关键字前加上访问控制符,但类本身只有两种访问控制,即public 和默认,父类不能是private 和 protected,否则子类无法继承。
public修饰的类能被所有的类访问,默认修饰(即class关键字前没有访问控制符)的类,只能被同一包中的所有类访问。
所以一个类若定义为默认类型,则只能在本包中被子类继承。若想定义的类能在任何地方被继承,则需定义为public类型。
第七部分 Java的命名规范
下面是java中的一些命名习惯,假设xxx,yyy,zzz分别是一个英文单词的拼写。
包名中的字母一律小写,如:xxxyyyzzz。
1>类名、接口名应当使用名词,每个单词的首字母大写,如:XxxYyyZzz。
2>方法名,第一个单词小写,后面每个单词的首字母大写,如:xxxYyyZzz。
3>变量名,第一个单词小写,后面每个单词的首字母大写,如:xxxYyyZzz。
4>常量名中的每个字母一律大写,如:XXXYYYZZZ。
第八部分 使用jar文件
1.jar –cvf jar文件 顶级包目录 //生成jar文件,并显示执行中的详细步骤信息
2.jar –tvf jar文件 //显示jar文件的目录结构内容
3jar –xvf jar文件 //解压jar文件到当前目录
4.jar –tvf >a.txt //把jar文件的目录结构内容输出到a.txt文件
5.用rar查看jar文件中的内容
6.注意压缩后的jar文件中的目录结构
7.快速查看jar包中是否有我们想找的类
注:
a.jar文件是一种压缩格式的文件,与zip压缩兼容
b.当我们把打包后的jar文件提供给别人,别人只需要将jar文件包含进classpath 中即可使用其中的类。JVM在装载类的时候会自动在内存中加压jar文件。
c.我们通常所用的JDK类放在lib下的rt.jar中。
- 黑马程序员——面向对象(二)---类的继承、多态性、匿名内部类、异常、包、访问控制、命名规范、jar文件
- 黑马程序员——java-面向对象二(继承,多态,抽象,接口,包,内部类)
- 黑马程序员——>第九天<面向对象(内部类-匿名内部类-异常)>
- 黑马程序员——学习日志6面向对象(多态,内部类,异常,访问权限)
- 黑马程序员——java第九、十天:面向对象(内部类、异常和包)
- 黑马程序员——面向对象(多态,内部类、异常、包)
- 黑马程序员 Java面向对象——(匿名)内部类
- 黑马程序员 Java面向对象——(匿名)内部类
- 黑马程序员 Java面向对象——(匿名)内部类
- 黑马程序员--Java学习笔记之面向对象思想(多态、内部类、匿名内部类、异常类)
- 黑马程序员 Java基础 面向对象:内部类 异常 包 jar包
- 黑马程序员—内部类与匿名内部类 异常
- 黑马程序员——【Java】面向对象——内部类_匿名内部类
- 黑马程序员---面向对象:内部类、异常和包
- 黑马程序员———面向对象之包、访问修饰符、内部类
- 黑马程序员_day09 面向对象(内部类访问规则,静态内部类,内部类定义原则,匿名内部类)
- 黑马程序员-Java的面向对象(抽象类、接口、内部类和继承、组合、多态)
- 黑马程序员——4.继承(接口、多态、内部类、异常、包)
- 使用jQuery使Div居中
- iOS 关于tableView cell的分割线的一些设置
- Linux下各文件夹的含义
- VP2.0中的纹理动画设计
- nginx 相关
- 黑马程序员——面向对象(二)---类的继承、多态性、匿名内部类、异常、包、访问控制、命名规范、jar文件
- STM32的BootLoader 从SD卡更新固件
- java中的LinkedList
- 将JNI的dll添加到jar包并发布和执行的方法
- SQL搜索含通配符的字符串
- 给IOS对象添加动态属性
- 远程桌面连接提示“您的凭据不工作” 解决方案!求解
- 在迷茫的时候,给自己一个方向和一份执着的坚持
- 新人报道