基础篇笔记地址：
http://tieba.baidu.com/p/1821169705
本书下载地址：
http://pan.baidu.com/share/link?shareid=30746&uk=1496293063
随书视频下载地址：
http://pan.baidu.com/share/link?shareid=79037&uk=1496293063
Oracle视频下载：
http://pan.baidu.com/share/link?shareid=8838&uk=1814985221
Java Web开发实战经典：
http://pan.baidu.com/share/link?shareid=63369&uk=2803467026
android开发实战经典下载：
http://pan.baidu.com/share/link?shareid=78094&uk=1613719751
这些东西是我以后努力的方向，有用的到的尽管拿走，就不用说谢谢了。

第六章面向对象（高级篇）
继承的基本概念
现在有一个Person类，其中包括name与age两个属性，而另外一个Student类，需要包含name、age、school3个属性，如图所示：

Person类：
class Person0601{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
Student类：
class Student0601{
private String name;
private int age;
private String school;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSchool() {
return school;
}
public void setSchool(String school) {
this.school = school;
}
}
从上面代码中可以发现Person类中已经存在有name和age两个属性，所以在Student类中不需要再重新声明这两个属性，这时就需要考虑是不是可以将Person类中的内容继续保留到Student类中，也就是继承。

Java中如果要想实现继承，可以直接使用以下语法来表示：
class 父类{}
class 子类 extends 父类{}
使用extends关键字实现继承
继承的实现：
class Person0602{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
class Student0602 extends Person0602{
}
class ExtDemo0601{
public static void main(String[] args) {
Student0602 st = new Student0602();
st.setName("张三");
st.setAge(20);
System.out.println("姓名：" + st.getName() + ",年龄：" + st.getAge());
}
}
从以上程序中可以法相，在Student类中并没有定义任何的操作，但是通过继承的功能可以直接把父类中的操作拿到子类中使用。当然，子类也可以定义自己的属性货方法，如下代码所示:
class Person0603{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
class Student0603 extends Person0603{
private String school;
public String getSchool() {
return school;
}
public void setSchool(String school) {
this.school = school;
}
}
class ExtDemo0602{
public static void main(String[] args) {
Student0603 st = new Student0603();
st.setName("张三");
st.setAge(20);
st.setSchool("哈佛");
System.out.println("姓名：" + st.getName() + ",年龄：" + st.getAge() + ",学校：" + st.getSchool());
}
}
以上程序中的Student类扩充了Person类，增加了学校的属性及对应的setter和getter方法，也就是说此时Student类中已经存在了3个属性及3组setter、getter方法，如图：

注意：只允许多层继承，而不能多重继承。

在Java中只允许单继承，不能使用多重继承，即一个子类只能继承一个父类。但是允许进行多层继承，即一个子类可以有一个父类，一个父类可以有一个父类。如图：

错误的继承代码：
class A{}
class B{}
//同时继承两个类，代码错误
class C extends A,B{}
C类同时继承了A类与B类，也就是说C类同时继承了两个父类，这是不允许的。
多层继承：
class A{}
class B extends A{}
class C extends B{}
由上面的代码可以发现B类继承了A类，而C类又继承了B类，也就是说B类是A类的子类，而C类则是A类的孙子类。
类图中的表示：

在使用继承时应该注意的是：子类是不能直接访问父类中的私有成员的，子类可以调用父类中的非私有方法，但是不能直接调用父类中的私有成员，如图：

代码：
class Student extends Person{
public void fun(){
System.out.println("父类中的name属性" + name);
System.out.println("父类中的age属性" + age);
}
}
以上代码中，子类直接访问了父类中的私有属性，所以在编译时编译器会通知用户name和age属性无法访问，如果此时不直接访问name或age属性，而是直接通过setter或getter方法调用则可以访问。
class Student extends Person{
public void fun(){
System.out.println("父类中的name属性" + getName);
System.out.println("父类中的age属性" + getAge);
}
}

真相来了：

方法的覆写
在继承的关系中也存在着方法覆写的概念，所谓的方法覆写就是指子类定义了与父类中同名的方法，但是在方法覆写时必须考虑到权限，即被子类覆写的方法不能拥有比父类方法更加严格的访问权限。
访问权限：private<default<public
方法的覆写：
class Person0605{
void print(){
System.out.println("Person-->void print(){}");
}
}
class Student0605 extends Person0605{
public void print(){
System.out.println("Student-->void print(){}");
}
}
class OverrideDemo01{
public static void main(String[] args) {
new Student0605().print();
}
}
从以上程序可以发现，Student子类定义了Person父类中同名的方法，但是在子类中此方法的访问权限被扩大了，符合覆写的概念，当方法被覆写之后，子类对象调用的将是被覆写后的方法。
错误的方法覆写：
class Person0606{
public void print(){
System.out.println("Person-->void print(){}");
}
}
class Student0606 extends Person0606{
void print(){
System.out.println("Student-->void print(){}");
}
}
class OverrideDemo02{
public static void main(String[] args) {
new Student0606().print();
}
}
以上代码编译无法通过。
如果现在子类的方法中访问父类的方法，则使用super关键字即可，代码如下：
调用父类中被子类覆写过的方法：
class Person0607{
void print(){
System.out.println("Person-->void print(){}");
}
}
class Student0607 extends Person0607{
public void print(){
super.print();
System.out.println("Student-->void print(){}");
}
}
class OverrideDemo03{
public static void main(String[] args) {
new Student0607().print();
}
}
运行结果：
Person-->void print(){}
Student-->void print(){}
从程序中可以发现，在子类中直接通过“super.方法()”形式，即可访问父类中的相关方法。
如果现在将父类的一个方法定义成private访问权限，在子类中将此方法声明为default访问权限，那么这样还叫做覆写吗？
不算方法覆写。先看如下代码：
class Person0608{
private void print(){
System.out.println("Person-->void print(){}");
}
void fun(){
this.print();
}
}
class Student0608 extends Person0608{
void print(){
System.out.println("Student-->void print(){}");
}
}
class OverrideDemo04{
public static void main(String[] args) {
new Student0608().fun();
}
}
运行结果：
Person-->void print(){}
可以发现，现在调用的方法是父类中的方法，也就是说此时子类并没有覆写父类中的方法，而是在子类中重新定义了一个新的方法，所以此时方法没有被覆写。
实际上与方法覆写概念相同的还有另外一个称为属性的覆盖。属性的覆盖：
class Person0609{
public String info = "MLDN";
}
class Student0609 extends Person0609{
public String info = "LXH";
public void print(){
System.out.println("父类中的属性" + super.info);
System.out.println("子类中的属性" + this.info);
}
}
class OverrideDemo05{
public static void main(String[] args) {
new Student0609().print();
}
}
运行结果：
父类中的属性MLDN
子类中的属性LXH
如果子类和父类声明了相同名称的属性，则在子类中直接访问时一定是采用“就近访问原则”，如果此时要调用父类中的属性，直接使用“super.属性”格式即可。
方法的重载与覆写：

============= super关键字作用====================
使用super关键字可以从子类中调用父类中的构造方法、普通方法和属性。
使用super调用父类中的指定构造方法：
class Person0610{
private String name;
private int age;
public Person0610(String name,int age){
this.setName(name);
this.setAge(age);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getInfo(){
return "姓名：" + this.getName() + "年龄：" + this.getAge();
}
}
class Student0610 extends Person0610{
private String school;
public Student0610(String name,int age,String school){
super(name, age);
this.setSchool(school);
}
public String getSchool() {
return school;
}
public void setSchool(String school) {
this.school = school;
}
public String getInfo(){
return super.getInfo() + "学校：" + this.getSchool();
}
}
class SuperDemo01{
public static void main(String[] args) {
Student0610 st10 = new Student0610("张三",39,"清华大学");
System.out.println(st10.getInfo());
}
}
运行结果：
姓名：张三年龄：39学校：清华大学
在以上程序的子类中使用super()的形式调用了父类中有两个参数的构造方法，然后子类中又覆写了父类中getInfo()方法，所以输出的内容是被子类覆写过的内容。
super与this的区别：

兄弟握紧枪，别发抖哦！

行车看美女，保险不赔偿，哈哈!

奥特曼削面

======================== 继承的应用====================
1.1 范例——继承的应用
定义一个整型数组类，要求包含构造方法，增加数据及输出数据成员方法，并利用数组实现动态内存分配。在此基础上定义出以下子类。
（1）排序类：实现排序。
（2）反转类：实现数据反向存放。
本程序要求数组实现动态的内存分配，也就是说其中数组的大小是由程序外部决定的，则在本类的构造方法中应该为类中的数组惊醒初始化操作，之后每次正佳数据时都应该判断数组的内容是否是满的，如果不是满的，则可以向其中添加；如果是满的，则不能添加，另外，要添加数据时，肯定需要有一个指向可以插入的下标，用于记录插入的位置，如图：

实现反转及排序类：
class Array{
private int temp[];
private int foot;
public Array(int len){
if (len > 0) {
this.temp = new int[len];
}else {
this.temp = new int[1];
}
}
public Boolean add(int i){
if (this.foot < this.temp.length) {
this.temp[foot] = i;
foot++;
return true;
}else {
return false;
}
}
public int[] getArray(){
return this.temp;
}
}

定义反转类
class ReverseArray extends Array{
public ReverseArray(int len ){
super(len);
}
public int[] getArray(){
int t[] = new int[super.getArray().length];
int count = t.length-1;
for (int i = 0; i < t.length; i++) {
t[count] = super.getArray()[i];
count--;
}
return t;
}
}

定义排序类
class SortArray extends Array{
public SortArray(int len){
super(len);
}
public int[] getArray(){
java.util.Arrays.sort(super.getArray());
return super.getArray();
}
}

print(a.getArray());
}
public static void print(int i[]){
for (int x = 0; x < i.length; x++) {
System.out.print(i[x] + "、");
}
}
}
运行结果：
truetruetruetruetruefalse
5、42、2、21、23、

==================final关键字=====================
final在Java中表示的意思是最终，也可以称为完结器。可以使用final关键字声明类、属性、方法，在声明时需要注意以下几点：
1.使用final声明的类不能有子类
2.使用final声明的方法不能被子类所覆写
3.使用final声明的变量即成为常量，常量不可以修改
使用final修饰的类不能有子类：
final class A {
}
class B extends A{
}
报错：The type B cannot subclass the final class A