java的继承性- 继承-final关键字-抽象类-接口-多态-异常-包-多线程-

继承：

继承的概述
继承的特点
super关键字
函数覆盖
子类的实例化过程
final关键字

继承的概述：
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
多个类可以称为子类，单独这个类称为父类或者超类。
子类可以直接访问父类中非私有的属性和行为。
通过extends关键字，让类与类之间产生继承关系。
class SubDemo extends Demo{}
继承的出现提高了代码的复用性。
继承的出现让类与类之间产生了关系，提供了多态的前提。
注意：子类不可以具备父类中私有的内容。父类怎么来的？共性 不断向上抽取而来的。

继承的特点：
java只支持单继承，不支持多继承。
一个类只能有一个父类，不能有多个父类。
class SbuDemo extends Demo{}//ok
class SbuDemo extends Demo1,Demo2......//error

java支持多层继承（继承体系）
class A{}
class B extends A{}
class C extends B{}

定义继承需要注意：
不要仅为了获取其他类中某个功能而去继承。
类与类之间要有所属关系（"is a "）关系，xx1是xx2的一种。（狗是动物的一种，猫是动物的一种）
因为多继承容易出现问题。两个父类中有相同的方法，子类到底要执行哪一个是不确定的。所以java不支持多继承，但将这种机制换了另一种安全的方式来体现，多实现。
多次继承出现在继承体系中，通常看父类中的功能，了解该体系的基本功能，建立子类对象即可使用该体系功能。

super关键字：
super和this的用法相像。
this代表本类对象的引用。
super代表父类在内存空间的标识。
当子父类出现同名成员时，可以用super进行区分。
子类要调用父类构造函数时，可以使用super语句。

函数覆盖（Override）
子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写。
父类中的私有方法不可以被覆盖。
在子类覆盖方法中，继续使用被覆盖的方法可以使用super.函数名获取。
覆盖注意事项：
覆盖时，子类方法权限一定要大于等于父类方法权限。
静态只能覆盖静态。
覆盖的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

子类的实例化过程：
子类中所有的构造函数默认都会访问父类中空参数的构造函数。
因为每一个构造函数的第一行都有一条默认的语句super()。
子类会具备父类中的数据，所以要先明确父类是如何对这些数据初始化的。
当父类中没有空参数的构造函数时，子类的构造函数必须通过this或者super语句指定要访问的构造函数。
总结：

1  继承需要具有继承关系（共性）才继承，不能单单为了用功能而继承。
2    java只支持单继承，不支持多继承。容易带来安全隐患：当多个父类中定义了相同功能，功能内容不同时，子类对象不确定运行哪一个。
final关键字：
final可以修饰类，方法，变量
final修饰的类不可以被继承
final修饰的方法不可以被覆盖
final修饰的变量是一个常量，只能被赋值一次
内部类只能访问被final修饰的局部变量(内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。)

抽象类：
抽象类概述
抽象类的特点
抽象类举例代码详解
抽象类相关问题

抽象类概述：
抽象定义：
抽象就是从多个事物中将共性的，本质的内容抽取出来。
例如：狼和狗共性都是犬科，犬科就是抽象出来的概念。
抽象类：
java中可以定义没有方法体的方法，该方法的具体实现由子类完成
该方法称为抽象方法，包含抽象方法的类就是抽象类。
抽象方法的由来：
多个对象都具有相同的功能，但是功能具体内容有所不同，那么在抽取过程中，
只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。

抽象类的特点：
抽象类和抽象方法必须用abstract关键字来修饰。
抽象方法只有方法声明，没有方法体，定义在抽象类中。
格式：修饰符abstract 返回值类型 函数名（参数列表）；
抽象类不可以被实例化，也就是不可以用new来创建对象，原因如下：
抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例。
例如：犬科是一个抽象的概念，真正存在的是狼和狗。
而且抽象类即使创建了对象，调用抽象方法也没有意义。
抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类。

抽象类举例代码详解：

雇员示例：
需求：公司中程序员有姓名，工号，薪水，工作内容。
项目经理除了有姓名，工号，薪水，工作内容，还有奖金。
对给出需求进行数据建模。

抽象类相关问题：

抽象类中是否有构造函数？
答案：有，抽象类是一个父类，要给子类提供实例的初始化。

抽象关键字abstract不可以和哪些关键字共存？
答案：
final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。
private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。
而抽象方法出现的就是需要被复写。
static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。
可是抽象方法运行没意义。
抽象类中可不可以没有抽象方法？
答案：可以。抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

接口：
格式：interface{}
接口中的成员修饰符是固定的。
成员变量：public static final
成员函数：public abstract
发现接口中的成员都是public的。
接口的出现将“多继承”通过另一种形式体现出来，即“多实现”

接口的特点：
接口是对外暴露的规则。
接口是程序的功能扩展。
接口的出现降低耦合性。
接口可以用来多实现。
类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
接口与接口之间可以有继承关系。
接口与抽象类：
共性：

都是不断抽取出来的抽象的概念。
区别1：

抽象类体现继承关系，一个类只能单继承。
接口体现实现关系，一个类可以多实现。
区别2：

抽象类是继承，是“is a ”关系
接口是实现，是“like a ”关系
区别3：

抽象类中可以定义非抽象方法，供子类直接使用。
接口的方法都是抽象，接口中的成员都有固定修饰符。
多态：
定义：某一类事物的多种存在形态。
例：动物中猫，狗。
猫这个对象对应的类型是猫类型。
猫 x = new 猫（）；
同时猫也是动物中的一种，也可以把猫称为动物。
动物 y = new 猫（）；
动物是猫和狗具体事物中抽取出来的父类型。
父类型引用指向了子类对象。
程序中体现：
父类或者接口的引用指向或者接收自己的子类对象。
好处和作用：
多态的存在提高了程序的扩展性和后期可维护性
前提：
需要存在继承或者实现关系
通常还有一个前提：存在覆盖。
多态的特点：
成员函数：
编译时：要查看引用变量所属的类中是否有所调用的成员。
在运行时：要查看对象所属的类中是否有所调用的成员。
成员变量：只看引用变量所属的类。

在多态中成员函数的特点：
在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
在运行时期：参阅对象所属的类中是否有调用的方法。
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

在多态中，成员变量的特点：
无论编译和运行，都参考左边(引用型变量所属的类)。

在多态中，静态成员函数的特点：
无论编译和运行，都参考左边。

instanceof : 用于判断对象的类型。 对象 intanceof 类型(类类型 接口类型)  

内部类：将一个类定义在另一个类里面，对里面那个类就称为内部类（内置类，嵌套类）

访问特点：
内部类可以直接访问外部类中的成员，包括私有成员。
之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this
而外部类要访问内部类中的成员必须要建立内部类的对象。
内部类的位置：
内部类定义在成员位置上：
可以被private static成员修饰符修饰
被static修饰的内部类只能访问外部类中的静态成员。
内部类定义在局部位置上：
也可以直接访问外部类中的成员。
同时可以访问所在局部中的局部变量，但必须是被final修饰的。
匿名内部类：
就是内部类的简化写法。
前提：
内部类继承或实现一个外部类或者接口。
格式为：
new 父类或者接口(){定义子类的内容}
简单理解：
就是建立一个带内容的外部类或者接口的子类匿名对象。
什么时候使用匿名内部类呢？
通常在使用方法是接口类型参数，并该接口中的方法不超过三个时，可以将匿名内部类作为参数传递。
增强阅读性。

异常：异常的体系：
Throwable:
Error:
通常出现重大问题，如：运行的类不存在或者内存溢出等。
不编写针对代码对其处理。
Exception：
在运行时运行出现的一些情况，可以通过try catch finally进行处理。
Exception和Error的子类名都是以父类名作为后缀。
Java在设计异常体系时，将容易出现的情况都封装成了对象。

Throwable中的方法：
getMessage():
获取异常信息，返回字符串。
toString():
获取异常类名和异常信息，返回字符串。
printStackTrace():
获取异常类名和异常信息，以及异常出现在程序中的位置，返回值void。
printStackTrace(PrintStreams):
通常用该方法将异常内容保存在日志文件中，以便查阅。

throws和throw:
throws用于标识函数暴露出的异常。
throw用于抛出异常对象。
throws和throw的区别：
throws用在函数上，后面跟异常类名。
throw用在函数内，后面跟异常对象。
定义功能方法时，需要把出现的问题暴露出来让调用者去处理。那么就通过throws在函数上标识。
在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。


异常处理：
try
{
需要检测的代码
}
catch(异常类 变量)
{
异常处理代码
}
finally
{
一定会执行的代码
}


finally代码块只有一种情况不会被执行，就是在之前执行了System.exit(0);


处理过程：
try中检测到异常，会将异常对象传递给catch，catch捕获到异常进行处理。
finally里通常用于关闭资源，比如：数据库资源，IO资源等。
需要注意：try是一个独立的代码块，在其中定义的变量，只在该变量块中有效。
如果try以外继续使用，需要在try建立引用，在try对其进行初始化。IO,Socket就会遇到。


自定义异常：
自定义类继承Exception或者其子类。
通过构造函数定义异常信息。
例：
class DemoException extends Exception
{
DemoException(String message)
{
super(message);
}
}
通过throw将自定义异常抛出。


异常细节：
RuntimeException以及其子类如果在函数中被throw抛出，可以不用在函数上声明。
一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类。
如果父类抛出多个异常，那么重写（覆盖）方法必须抛出那些异常的一个子集，不能抛出新的异常。
介绍异常在分层设计时的层内封装。


包(package)
对类文件进行分类管理
给类提供多层命名空间
写在程序文件的第一行
类名的全称是 包名.类名
包也是一种封装形式


classpath
给JVM提供的一个环境变量
指定类或者包所在的路径
classpath变量值的最后有分号与无分号的区别。
值的结尾处如果加上分号，那么JVM在classpath目录下没有找到要指定的类文件，会在当前目录下在查找一次。
值的结尾出如果没有分号，那么JVM在classpath目录下没有找到要指定的类文件，不会在当前目录下查找，即使当前目录下有，也不会运行。
思考：在开发时，分号是否需要呢？
不需要分号，不然不知道运行的到底是哪一个类文件。


包之间的访问
被访问包中的类权限必须是public的
类中的成员权限：public或者protected
protected是为其他包中的子类提供的一种权限

import
简化类名
一个程序文件中只有一个package，可以有多个import
用来导入包中的类，不导入包中的包。
通常写import mypack.Demo;
而不写import mypack.*;//因为如果使用通配符，所有的类文件都导入了进来，比较浪费内存空间。


Jar包
Java的压缩包
方便项目的携带
方便于使用，只要在classpath设置jar路径即可。
数据库驱动，SSH框架等都是以jar包体现的。


jar包的操作
通过jar.exe工具对jar的操作。
创建jar包：
jar cvf -d . mypack.jar packa packb //-d： 指定把jar包存放的路径 .：当前目录
查看Jar包：
jar tvf mypack.jar [>定向文件]//也可以指定路径查看，，定向文件：  >c:\1.txt
解压缩：
jar xvf mypack.jar
自定义jar包的清单文件：
jar cvfm mypack.jar mf.txt packa packb

c:创建压缩文档
f:制订存档名称
v:显示详细信息
m:加入自定义清单信息
通常应用于java制作的图形界面程序，在清单文件中其中定一个Main-Class:空格 带有主函数的类名回车
在设置一下jar文件的打开方式通过javaw - jar就可以双击执行了。




多线程：
进程
线程（例：FlashGet）
多线程存在的意义
线程的创建方式
多线程的特性


创建线程方式一：
继承Thread类
1，子类覆盖父类中的run方法，将线程运行的代码存放在run中
Thread类用于描述线程。
该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法。
也就是说Thread类中的run方法，用于存储线程要运行的代码。
2，建立子类对象的同时线程也被创建
3，通过调用start方法开启线程


线程的四种状态：
被创建-->start()-->运行-->sleep()--wait()--notify()-->冻结-->run()结束-->消亡
运行：start()
冻结：sleep()  wait()  notify()
消亡：run()结束
sleep方法需要指定睡眠时间，单位是毫秒
一个特殊的状态：就绪，具备了执行资格，但是还没有获取资源。


创建线程方式二：
实现Runnable接口
1，子类覆盖接口中的run方法
2，通过Thread类创建线程，并将实现了Runnable接口的子类对象作为参数传递给Thread类的构造函数
3，Thread类对象调用start方法开启线程。
思考：为什么要给Thread类的构造函数传递Runnable的子类对象？
因为，自定义的run方法所属的对象是Runnable接口的子类对象。
所以要让线程去运行指定对象的run方法。就必须明确该run方法所属对象。


线程安全问题：
导致安全问题出现的原因：
多个线程访问出现延迟。
线程随机性。
注：线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。


同步(synchronized)：
格式：
synchronized(对象)
{
需要同步的代码;
}
同步可以解决安全问题的根本原因就在那个对象上。
该对象如同锁的功能。


同步的前提：
同步需要两个或者两个以上的线程。
多个线程使用的是同一个锁。
为满足这两个条件，不能称其为同步
同步的弊端：当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。


同步函数：
格式：在函数上加synchronized修饰符即可。
思考：同步函数用的是哪个锁呢？
函数需要被对象调用。那么函数都有一个所属对象引用。就是this。
所以同步函数使用的锁是this。


线程间通信：
input-->资源-->output
思考：
1，wait(),notify(),notifyAll(),用来操作线程为什么定义在Object类中？
1，这些方法存在于同步中。
2，使用这些方法时，必须要标识所属的同步的锁。
3，锁可以是任意对象，所以任意对象调用的方法一定定义在Object类中。


毕老师总结：因为这些方法要对持有监视器(锁)的线程操作。
所以要使用在同步中，因为只有同步才具有锁。
因为这些方法在操作同步中线程时，都必须要标识它们所操作线程持有的锁，
只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。
不可以对不同锁中的线程进行唤醒。
也就是说，等待和唤醒必须是同一个锁。


而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。
2，wait()  sleep()有什么区别？
1，wait():释放CPU执行权，释放锁。
2，sleep():释放CPU执行权，不释放锁。


JDK1.5 中提供了多线程升级解决方案。
将同步Synchronized替换成现实Lock操作。
将Object中的wait，notify notifyAll，替换了Condition对象。
该对象可以Lock锁 进行获取。
该示例中，实现了本方只唤醒对方操作。


Lock:替代了Synchronized
lock锁
unlock 解锁（释放锁的动作一定要执行）
newCondition()获取和该锁相关联的Condition对象，该对象中有等待，唤醒，唤醒所有方法。


Condition：替代了Object wait notify notifyAll
await(); 等待
signal(); 唤醒
signalAll(); 唤醒所有


停止线程：
1，定义循环结束标记
因为线程运行代码一般都是循环，只要控制了循环即可。
2，使用interrupt(中断)方法。
该方法是结束线程的冻结状态，使线程回到运行状态中来。
注：stop方法已经过时不再使用。


线程类的其他方法：
setPriority(int num) 更改线程的优先级，默认5；
setDaemon(boolean b)  守护线程：将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。 该方法必须在启动线程前调用。
join() 等待该线程终止。
join:
当A线程执行到了B线程的.join()方法时，A就会等待。等B线程都执行完，A才会执行。
join可以用来临时加入线程执行。
自定义线程名称
toString()  返回该线程的字符串表示形式，包括线程名称，优先级和线程组。
static void yield()  暂停当前正在执行的线程对象，并执行其他线程。