黑马程序员-java基础继承、抽象、接口

最新推荐文章于 2024-10-05 12:07:50 发布

hks2012

最新推荐文章于 2024-10-05 12:07:50 发布

阅读量405

点赞数

文章标签： class interface string java android c

本文链接：https://blog.csdn.net/hks2012/article/details/7601678

版权

---------------------- android培训、java培训、期待与您交流！ ----------------------

extends 继承：把类的公有成员提取出来组成一个父类，其他继承这个类的类就是其子类。

格式 public A extens B｛｝就是说A类继承B类 A类就是子类 B类就是父类

继承提高了代码的复用性，并且让类与类之间产生了关系，有了个关系才有了多态的特性。
在java中只支持单继承不支持多继承。多继承容易带来安全隐患，因为当多个父类中内拥有相同功能，但功能内容不一样

时，子类不知道调用那一个。 java支持多层继承，A继承B，B继承C。

在使用继承时要创建最子类的对象，因为1 父类可能不能创建对象 2 创建最子类对象可以实用更多功能包括基本的也包括特

有的。

super关键字： super代表父类对象的引用
子类继承父类后。类的特点：
1 当子类有父类的相同的属性的时候，子类掉用的时候先访问子类的属性。子类要访问本类对象的变量时用this，访问父类

对象的变量时用super；

2 子类中出现和父类一样的方法，当子类调用该方法时会运行子类的方法。这就是子类重写了父类的方法。子类重写父类的

方法必须保证子类权限大雨等于父类权限，否则编译失败。且静态方法只能重写静态方法

3 子类中的所有构造函数，都会默认调用父类的无参构造函数，因为在子类构造函数的第一行有隐式的代码：super（）；如

果父类中定义了有参的构造函数，则必须在子类中显式的掉用父类的有参构造函数，或者在父类中添加显式的无参构造函数

。不然会报错。当然也可以在子类中的第一行手动用this语句来访问子类的构造函数，但是子类中至少有一个构造函数访问

父类的构造函数。

this 语句和super不同时在构造函数中，因为他们都是执行初始化动作，都必须在第一行。

final：最终。是一个修饰符

1 可以修饰类函数变量。
2 被final修饰的类不能被继承。为了避免类被继承，被子类重写功能。
3 被final修饰的方法，不能被重写。
4 被final修饰的变量是常量只能赋值一次。final既可以修饰成员变量，也可以修饰局部变量。常量的所有字母都大写，

如果多个单词用下划线连接

//父类
public class Person {

public String name="lisi";
public int age=40;

Person(){
System.out.println("Person");
}

public void add(){
System.out.println("name="+name+",age="+age);
}

}

//子类
public class Student extends Person {

public String name="zhangsan";
public int age=20;

Student(){
  //这里隐式调用了super();
  System.out.println("Student");
}
// 子类重写父类的方法
public void add() {
  System.out.println("name="+name+",age="+age);
}

}

public class Test {
public static void main(String[] args) {
Person p = new Student();//父类对象指向子类的引用。子类若没有name和age属性，则打印父类的值

p.add();
}

}

输出结果 Person
Student
name=zhangsan,age=20

抽象类：当多个类中出现功能相同，但是功能的主体不同。这是可以向上抽取，只抽取功能的的定义而不抽取功能的主体。

就可以定义一个抽象类。

抽象类特点：1 抽象方法一定在抽象类中 2 抽象类和抽象方法用abstract关键字修饰 3抽象类不能被是立法 4抽象方法要

想被实用，必须由子类重写父类的抽象方法。如果子类只重写了部分抽象方法，那么该子类还是一个抽象类

抽象类与普通类的区别：1抽象类不能被实例化 2 可以有抽象方法

模版方法模式：在定义功能是。功能一部分是确定的，但有一部分不能确定，而确定的部分在实用不确定的部分，那么这时

就将不确定的部分暴露出去给子类去实现。