super:

(1)使用super关键字访问父类的非私有属性或调用父类的非私有方法,具体格式如下:

  1. super.属性
  2. super.方法(参数1,参数2,....)

接下来举个例子方便大家理解

首先我们定义个Student类:

  1. class Student {
  2. String name;
  3. String sex;
  4. int age;
  5. void jieshao(){
  6. System.out.println("大家好我是一个学生");
  7. }
  8. }

然后,我们写一个小帅类,继承这个学生类:

  1. class xiaoshuai extends Student {
  2. void jieshao() {
  3. System.out.println("我叫小帅");
  4. }
  5. void niubi(){
  6. super.jieshao();
  7. System.out.println("我很牛逼");
  8. }
  9. }

注意看,这个男人叫小帅,他继承了Student类的所有属性与方法后,重写了介绍(jieshao)这个方法。这个时候小帅类中的jieshao方法就被修改了,但如果我们还想用父类中的jieshao方法,我们就可以加个super,变成super.jieshao。就比如下面这个牛逼方法(niubi)

最后,我们写个Demo类测试一下成果

  1. public class Demo1{
  2. public static void main(String[] args) {
  3. xiaoshuai xm=new xiaoshuai();
  4. xm.niubi();
  5. }
  6. }

完整代码:

  1. public class Demo1{
  2. public static void main(String[] args) {
  3. xiaoshuai xm=new xiaoshuai();
  4. xm.niubi();
  5. }
  6. }
  7. class Student {
  8. String name;
  9. String sex;
  10. int age;
  11. void jieshao(){
  12. System.out.println("大家好我是一个学生");
  13. }
  14. }
  15. class xiaoshuai extends Student {
  16. void jieshao() {
  17. System.out.println("我叫小帅");
  18. }
  19. void niubi(){
  20. super.jieshao();
  21. System.out.println("我很牛逼");
  22. }
  23. }

运行结果如下:

 

 接下来我们来讲super的第二个用法:

(2)使用super关键字调用父类中指定的构造方法:

首先写一个Studengt类

  1. class Student {
  2. private String name;
  3. private String sex;
  4. private int age;
  5. public Student(String name, String sex, int age) {
  6. this.name = name;
  7. this.sex = sex;
  8. this.age = age;
  9. }
  10. public String getName() {
  11. return name;
  12. }
  13. public void setName(String name) {
  14. this.name = name;
  15. }
  16. public String getSex() {
  17. return sex;
  18. }
  19. public void setSex(String sex) {
  20. this.sex = sex;
  21. }
  22. public int getAge() {
  23. return age;
  24. }
  25. public void setAge(int age) {
  26. this.age = age;
  27. }
  28. public String toString() {
  29. return "name=" + name+
  30. ", sex=" + sex +
  31. ", age=" + age;
  32. }
  33. }

接着我们写一个小帅类,但是不同的是,小帅多了一个属性,num,然后构造方法带四个参数:

  1. class xiaoshuai extends Student {
  2. int num;
  3. public xiaoshuai(String name, String sex, int age,int num) {
  4. super(name, sex, age);
  5. this.num=num;
  6. }
  7. @Override
  8. public String toString() {
  9. return super.toString()+"," +
  10. "num=" + num;
  11. }
  12. }

我们就可以这么写,用super();的方式,讲父类的构造方法直接调用,然后在构造方法中加入num属性。

写一个Demo类运行:

  1. public class Demo1{
  2. public static void main(String[] args) {
  3. xiaoshuai xs=new xiaoshuai("xs","man",20,01);
  4. System.out.println(xs.toString());
  5. }
  6. }

最后让我们来看一下结果

final:

final其实很容易掌握,只有以下三个用法:

(1)使用final关键字修饰的类不能有子类

(2)使用final关键字修饰的方法不能被子类重写

(3)使用final关键字修饰的变量是常量,常量不能被修改