[零基础学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
image
如果要打印父类中的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属性输出了哈~这就叫属性的复写
image
属性一般情况下都要求被封装的,被封装之后肯定子类是无法看见父类中的内容,所以根本就无法覆写。 
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关键字时也是提到过的哈~
image
在使用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);    
        }    
}; 

现在编译就通过了哈~
image
本季主要知识点:
1、继承的类图表示 
2、继承的题目
现在我们来看个Demo03:
class A    
{    
};    
class B  extends A    
{    
}; 

这个滴继承关系我们来用类图表示
image
知道了上面的内容,我们来看下练习题:
image
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());    
        }    
}; 

image
现在我们将其导入类图哈~
image
下面再来看一个练习题哈~
image
      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");    
                }    
        }    
};    

看下效果:
image 
类图如下:
总结 
巩固了继承的概念,继承到底继承了那些东西,super的使用,方法的覆写
#######################################################################








本文转自redking51CTO博客,原文链接:http://blog.51cto.com/redking/125955 ,如需转载请自行联系原作者
目录
打赏
0
0
0
0
102
分享
相关文章
Java:面向对象
本文介绍了Java编程中的核心概念,包括包的命名规范与自动导入机制、构造方法的特点与使用、`this`和`super`关键字的作用、继承的基本规则、访问权限的设置、封装的意义、多态的实现原理以及`static`关键字的用法。通过详细解析每个知识点,并结合代码示例,帮助读者深入理解Java面向对象编程的核心思想与实践技巧。内容适合初学者及进阶开发者学习参考。
java面试-基础语法与面向对象
本文介绍了 Java 编程中的几个核心概念。首先,详细区分了方法重载与重写的定义、发生阶段及规则;其次,分析了 `==` 与 `equals` 的区别,强调了基本类型和引用类型的比较方式;接着,对比了 `String`、`StringBuilder` 和 `StringBuffer` 的特性,包括线程安全性和性能差异;最后,讲解了 Java 异常机制,包括自定义异常的实现以及常见非检查异常的类型。这些内容对理解 Java 面向对象编程和实际开发问题解决具有重要意义。
|
7月前
|
java中面向过程和面向对象区别?
java中面向过程和面向对象区别?
94 1
还不明白面向对象? 本文带你彻底搞懂面向对象的三大特征(2024年11月Java版)
欢迎来到我的博客,我是瑞雨溪,一名热爱JavaScript和Vue的大一学生。如果你从我的文章中受益,欢迎关注我,我将持续更新更多优质内容。你的支持是我前进的动力!🎉🎉🎉
77 0
还不明白面向对象? 本文带你彻底搞懂面向对象的三大特征(2024年11月Java版)
面向对象设计原则在Java中的实现与案例分析
【10月更文挑战第25天】本文通过Java语言的具体实现和案例分析,详细介绍了面向对象设计的五大核心原则:单一职责原则、开闭原则、里氏替换原则、接口隔离原则和依赖倒置原则。这些原则帮助开发者构建更加灵活、可维护和可扩展的系统,不仅适用于Java,也适用于其他面向对象编程语言。
149 2
Java基础-面向对象
Java基础-面向对象
70 0
|
10月前
|
java中面向过程和面向对象区别?
java中面向过程和面向对象区别?
87 4
接口和抽象类【Java面向对象知识回顾②】
本文讨论了Java中抽象类和接口的概念与区别。抽象类是不能被实例化的类,可以包含抽象和非抽象方法,常用作其他类的基类。接口是一种纯抽象类型,只包含抽象方法和常量,不能被实例化,且实现接口的类必须实现接口中定义的所有方法。文章还比较了抽象类和接口在实现方式、方法类型、成员变量、构造方法和访问修饰符等方面的不同,并探讨了它们的使用场景。
接口和抽象类【Java面向对象知识回顾②】
封装,继承,多态【Java面向对象知识回顾①】
本文回顾了Java面向对象编程的三大特性:封装、继承和多态。封装通过将数据和方法结合在类中并隐藏实现细节来保护对象状态,继承允许新类扩展现有类的功能,而多态则允许对象在不同情况下表现出不同的行为,这些特性共同提高了代码的复用性、扩展性和灵活性。
封装,继承,多态【Java面向对象知识回顾①】
Java 面向对象
Java 是一种面向对象的编程语言,通过对象与类的概念组织代码和数据。面向对象编程的核心包括类、对象、继承、多态、封装和抽象。类是对象的蓝图,定义了属性和行为;对象则是类的实例。继承允许子类继承父类的属性和方法,增强代码复用性;多态则支持通过相同接口调用不同类型对象的行为,包括方法重载和重写。封装通过公共方法隐藏对象细节,提高安全性;抽象则对对象特征进行提炼,通过抽象类和接口实现。理解这些概念有助于设计高效、可维护的 Java 应用程序。
67 0
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等

登录插画

登录以查看您的控制台资源

管理云资源
状态一览
快捷访问