[零基础学JAVA]Java SE面向对象部分-14.面向对象高级（02） 推荐

本季先重点回顾了方法的重载与覆写、super与this关键字的区别。之后主要以实例讲解为主，主要回顾了JAVA中的继承及数组的基本概念，之后又讲解了JAVA中继承的图形表示。
上季内容回顾：
1、继承的使用和概念，继承的各种限制
2、子类对象的实例化过程
3、方法覆写
4、super的使用

有两个题目在面试中经常会涉及到哈~~~

[b]面试一：解释一下方法的覆写与方法的重载的区别：
[b]


面试二：super与this的区别



属性覆写[/b][/b]（较少使用）
我们来简单验证下哈

class A
{
String name = "redking";
};
class B extends A
{
//子类定义了一个和父类中相同的name属性
String name = "Michael";
public void print()
{
//与System.out.println(this.name);效果相同
System.out.println(name);
}
};
public class Demo01
{
public static void main(String args[])
{
B b = new B();
b.print();
}
};
程序打印了在子类中定义的name属性：Michael



如果要打印父类中的name属性，我们可以修改成super.name

class A
{
String name = "redking";
};
class B extends A
{
//子类定义了一个和父类中相同的name属性
String name = "Michael";
public void print()
{
//与System.out.println(this.name);效果相同
System.out.println(name);
//如果要打印父类中的name属性，我们可以修改成super.name
System.out.println(super.name);
}
};
public class Demo01
{
public static void main(String args[])
{
B b = new B();
b.print();
}
};
父类中的name属性输出了哈~这就叫属性的复写



属性一般情况下都要求被封装的，被封装之后肯定子类是无法看见父类中的内容，所以根本就无法覆写。

super与this调用构造方法能同时写在一个构造方法之中吗？答案是不行哈~
Super调用构造方法时，一定要放在构造方法的首行，this调用构造方法时也必须放在首行，如果两个都放在首行，则肯定冲突。
有人认为可以不调用super方法哈，我们看下面的Demo02

class A
{
public A(){}
};
class B extends A
{
//里面有三个构造方法
public B()
{
this("abc",888);
}
public B(String name)
{
this();
}
public B(String name,int age)
{
this(name);
}
};

这样就产生了一个问题，我们在讲this关键字时也是提到过的哈~



在使用this()调用构造方法的时候肯定要留下一个出口。否则编译通不过哈~

class A
{
public A(){}
};
class B extends A
{
//里面有三个构造方法
public B()
{
//最好把this("abc",888);修改成super()作为出口哈~
super();
}
public B(String name)
{
this();
}
public B(String name,int age)
{
this(name);
}
};

现在编译就通过了哈~



本季主要知识点：
1、继承的类图表示
2、继承的题目
现在我们来看个Demo03:

class A
{
};
class B extends A
{
};

这个滴继承关系我们来用类图表示



知道了上面的内容，我们来看下练习题：




class Person
{
private String name;
private String addr;
private char sex;
private int age;
//一般参数少的构造方法写在上面哈~~
public Person(){}
public Person(String name,String addr)
{
this.setName(name);
this.setAddr(addr);
this.setSex('男');
this.setAge(27);
}
public Person(String name,String addr,char sex,int age)
{
this.setName(name);
this.setAddr(addr);
this.setSex(sex);
this.setAge(age);
}
public void setName(String name)
{
this.name = name;
}
public void setAddr(String addr)
{
this.addr = addr;
}
//M：表示男；F：表示女
public void setSex(char sex)
{
this.sex = sex;
}
public void setAge(int age)
{
this.age = age;
}
public String getName()
{
return this.name;
}
public String getAddr()
{
return this.addr;
}
public char getSex()
{
return this.sex;
}
public int getAge()
{
return this.age;
}
//所有的内容应该交给外部输出
public String getInfo()
{
return "姓名："+this.name
+"，地址："+this.addr
+"，性别："+(this.sex=='M'?"男":"女")
+"，年龄："+this.age;
}
};
class Student extends Person
{
private float math;
private float english;
public Student()
{
//默认隐含了super();
super();
}
public Student(String name,String addr)
{
super(name,addr);
}
public Student(String name,String addr,char sex,int age,float math,float english)
{
super(name,addr,sex,age);
this.setMath(math);
this.setEnglish(english);
}
public void setMath(float math)
{
this.math = math;
}
public void setEnglish(float english)
{
this.english = english;
}
public float getMath()
{
return this.math;
}
public float getEnglish()
{
return this.english;
}
public String getInfo()
{
return super.getInfo()+"，数学成绩："+this.math+"，英语成绩："+this.english;
}
};
public class Demo04
{
public static void main(String args[])
{
//使用学生类
Student stu = new Student("王乾","无锡",'M',27,98.0f,99.0f);
System.out.println(stu.getInfo());
}
};




现在我们将其导入类图哈~



下面再来看一个练习题哈~



Java中在声明数组长度的时候可以给一个变量，变量的内容可以在程序运行时自动决定。

//声明数组类
class Array
{
//设置整型数组
private int i[] = null;
//设置一个脚标表示插入的点位置
private int foot = 0;
//在构造方法处写入数组的大小
public Array(int len)
{
this.i = new int[len];
}
//输入数据时必须保证数组里有空间接收此数据
public boolean add(int temp)
{
//先判断是否数组中已经加满了内容
if (this.foot<this.i.length)
{
//表示数组里面依然有空间可以插入数据
this.i[this.foot] = temp;
//修改脚标
this.foot++;
return true;
}
else
{
return false;
}
}
//理解为得到全部的数组内容
public int[] getAll()
{
return this.i;
}
};
//定义排序的子类
class SortArray extends Array
{
//排序类是Array类的子类，所以此处必须传入一个大小
public SortArray(int len)
{
super(len);
}
//得到的是一个排序后的数组
//最好复写getAll()方法
public int[] getAll()
{
//但是此方法返回的是一个排序好的数组
//采用由低到高的方式排序
for (int i=0;i<super.getAll().length ;i++ )
{
for (int j=0;j<super.getAll().length-1 ;j++ )
{
if (super.getAll()[i]<super.getAll()[j])
{
//两个数字相换
int t = super.getAll()[i];
super.getAll()[i]=super.getAll()[j];
super.getAll()[j]=t;
}
}
}
return super.getAll();
}
};
class ReverseArray extends Array
{
public ReverseArray(int len)
{
super(len);
}
public int[] getAll()
{
//反转指的是与插入的顺序相反即可
int temp[] = new int[super.getAll().length];
//定义一个temp脚标的变量
int cou = 0;
for (int i=super.getAll().length-1;i>=0 ;i-- )
{
temp[cou] = super.getAll()[i];
cou++;
}
return temp;
}
}
public class Demo05
{
public static void main(String args[])
{
SortArray sa = new SortArray(8);
sa.add(15);
sa.add(22);
sa.add(07);
sa.add(82);
sa.add(75);
sa.add(99);
sa.add(27);
sa.add(89);
print(sa.getAll());
System.out.println("\n"+"**********排序类与反转类分割线哈~~~**********");
ReverseArray ra = new ReverseArray(8);
ra.add(15);
ra.add(22);
ra.add(07);
ra.add(82);
ra.add(75);
ra.add(99);
ra.add(27);
ra.add(89);
print(ra.getAll());
}
public static void print(int temp[])
{
for (int i=0;i<temp.length ;i++ )
{
System.out.print(temp[i]+"\t");
}
}
};

看下效果：



类图如下：



总结
巩固了继承的概念，继承到底继承了那些东西，super的使用，方法的覆写
#######################################################################