[零基础学JAVA]Java SE面向对象部分-14.面向对象高级（02）-阿里云开发者社区

本季先重点回顾了方法的重载与覆写、super与this关键字的区别。之后主要以实例讲解为主，主要回顾了JAVA中的继承及数组的基本概念，之后又讲解了JAVA中继承的图形表示。

上季内容回顾：

1、继承的使用和概念，继承的各种限制
2、子类对象的实例化过程
3、方法覆写
4、super的使用

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

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

面试二：super与this的区别

属性覆写 （较少使用）

我们来简单验证下哈

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的使用，方法的覆写

#######################################################################

本文转自redking51CTO博客，原文链接：http://blog.51cto.com/redking/125955 ，如需转载请自行联系原作者

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

热门文章

最新文章

相关课程

相关电子书

相关实验场景