面向对象高级02回顾了方法的重载与覆写super与this关键字的区别JAVA中继承的图形.docx
《面向对象高级02回顾了方法的重载与覆写super与this关键字的区别JAVA中继承的图形.docx》由会员分享，可在线阅读，更多相关《面向对象高级02回顾了方法的重载与覆写super与this关键字的区别JAVA中继承的图形.docx（12页珍藏版）》请在冰豆网上搜索。
面向对象高级02回顾了方法的重载与覆写super与this关键字的区别JAVA中继承的图形
14.面向对象高级（02）
本季先重点回顾了方法的重载与覆写、super与this关键字的区别。
之后主要以实例讲解为主，主要回顾了JAVA中的继承及数组的基本概念，之后又为读者讲解了JAVA中继承的图形表示。
blog:
[零基础学JAVA]JavaSE面向对象部分-14.面向对象高级（02）2009-01-11
本季先重点回顾了方法的重载与覆写、super与this关键字的区别。
之后主要以实例讲解为主，主要回顾了JAVA中的继承及数组的基本概念，之后又讲解了JAVA中继承的图形表示。
上季内容回顾：
1、继承的使用和概念，继承的各种限制
2、子类对象的实例化过程
3、方法覆写
4、super的使用
有两个题目在面试中经常会涉及到哈~~~
面试一：
解释一下方法的覆写与方法的重载的区别：
面试二：
super与this的区别
属性覆写（较少使用）
我们来简单验证下哈
class A
{
Stringname= "redking";
};
class B extends A
{
//子类定义了一个和父类中相同的name属性
Stringname= "Michael";
public void print（）
{
//与System.out.println（this.name）;效果相同
System.out.println（name）;
}
};
public class Demo01
{
public static void main（Stringargs[]）
{
Bb= new B（）;
b.print（）;
}
};
程序打印了在子类中定义的name属性：
Michael
如果要打印父类中的name属性，我们可以修改成super.name
class A
{
Stringname= "redking";
};
class B extends A
{
//子类定义了一个和父类中相同的name属性
Stringname= "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（Stringargs[]）
{
Bb= 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（Stringname）
{
this（）;
}
public B（Stringname,int age）
{
this（name）;
}
};
这样就产生了一个问题，我们在讲this关键字时也是提到过的哈~
在使用this（）调用构造方法的时候肯定要留下一个出口。
否则编译通不过哈~
class A
{
public A（）{}
};
class B extends A
{
//里面有三个构造方法
public B（）
{
//最好把this（"abc",888）;修改成super（）作为出口哈~
super（）;
}
public B（Stringname）
{
this（）;
}
public B（Stringname,int age）
{
this（name）;
}
};
现在编译就通过了哈~
本季主要知识点：
1、继承的类图表示
2、继承的题目
现在我们来看个Demo03:
class A
{
};
class B extends A
{
};
这个滴继承关系我们来用类图表示
知道了上面的内容，我们来看下练习题：
class Person
{
private Stringname;
private Stringaddr;
private char sex;
private int age;
//一般参数少的构造方法写在上面哈~~
public Person（）{}
public Person（Stringname,Stringaddr）
{
this.setName（name）;
this.setAddr（addr）;
this.setSex（'男'）;
this.setAge（27）;
}
public Person（Stringname,Stringaddr,char sex,int age）
{
this.setName（name）;
this.setAddr（addr）;
this.setSex（sex）;
this.setAge（age）;
}
public void setName（Stringname）
{
this.name=name;
}
public void setAddr（Stringaddr）
{
this.addr=addr;
}
//M：
表示男；F：
表示女
public void setSex（char sex）
{
this.sex=sex;
}
public void setAge（int age）
{
this.age=age;
}
public StringgetName（）
{
return this.name;
}
public StringgetAddr（）
{
return this.addr;
}
public char getSex（）
{
return this.sex;
}
public int getAge（）
{
return this.age;
}
//所有的内容应该交给外部输出
public StringgetInfo（）
{
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（Stringname,Stringaddr）
{
super（name,addr）;
}
public Student（Stringname,Stringaddr,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 StringgetInfo（）
{
return super.getInfo（）+"，数学成绩：
"+this.math+"，英语成绩：
"+this.english;
}
};
public class Demo04
{
public static void main（Stringargs[]）
{
//使用学生类
Studentstu= 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[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 {
for （int j=0;j {
if （super.getAll（）[i] {
//两个数字相换
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（Stringargs[]）
{
SortArraysa= 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"+"**********排序类与反转类分割线哈~~~**********"）;
ReverseArrayra= new ReverseArray（8）;
ra.add（15）;
ra.add（22）
升级会员 