[零基础学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的使用，方法的覆写 #######################################################################

本文出自 “王乾De技术博客” 博客，谢绝转载！