------- android培训、java培训、期待与您交流! ----------
继承
继承是指一个对象直接使用另一对象的属性和方法。
示例:一个Student类,一个Worker类,并把他们的共性都提取出来形成一个Person类。
Person类
//该类提取除了人的属性name和age
public class Person {
String name = "张三";
int age;
public void eat() {
System.out.println("eat");
}
}
Student类
//Student通过extends关键字继承Person类,便继承了Person类的属性和方法
public class Student extends Person {
//学生类的学习方法
public void study() {
System.out.println("学习");
}
public static void main(String[] x){
Student student = new Student();
student.eat();
student.study();
System.out.println(student.age);
}
}
Worker类
//Worker通过extends关键字继承Person类,便继承了Person类的属性和方法
public class Worker extends Person {
//Worek类自有的方法
public void work() {
System.out.println("工作");
}
public static void main(String[] x){
Worker worker = new Worker();
//调用自身的方法
worker.work();
//调用从父类继承的方法
worker.eat();
System.out.println(worker.name);
}
}
上述Student和Worker通过extends关键字继承Person类,便拥有了Person类的属性和方法。
Person类就是Student类和Worker类的父类;Student类和Worker类就是Person类的子类;
继承关系中的super和this
在继承关系中如果子类子类与父类中出现了同名的属性,且属性法都不是私有的时候;
那么直接调用这个同名的属性子类中的属性会优于父类中属性;
这是为了区分子类和父类的属性就的使用super关键字和this关键字。
this代表子类的属性,super代表父类的属性。
例如:
public class Person {
String name = "张三";
public void eat() {
System.out.println("eat");
}
}
public class Stu extends Person {
String name = "李四";
public void Person() {
System.out.println(name); //默认打印子类的name属性值“李四”
System.out.println(this.name); //打印子类的name属性值“李四”
System.out.println(super.name); //打印父类的name属性值“张三”
}
}
this代表子类对象的引用,super代表父类对象的引用。
覆盖(重写)
当子类继承父类,子类中的方法和父类中德方法一致时,这时子类的方法会优于父类的方法,系统会直接调用子类的方法;这种情况就叫覆盖,也叫重写。
public class Phone{
public void show() {
System.out.println("来电显示号码");
}
}
public class Iphone extends Phone {
//覆盖父类中的show方法
public void show() {
super.show(); //继承父类中show方法的功能
System.out.println("来电显示姓名"); //子类方法中新增的方法
}
}
上述子类不仅具有自己show方法的功能,还继承了父类show方法的功能。
注意:1、子类覆盖父类,必须保证子类的权限大于和等于父类的权限,才可能覆盖,否则覆盖失败。
2、静态方法只能覆盖静态方法。
从载:函数的参数列表不一样。
从载:函数的参数列表不一样。
从写:子父类方法一摸一样。
子类的所有的构造函数,默认都会访问父类中德构造函数,因为子类每一个构造函数内的第一行都有一个隐式的super();
当父类中没有空参数的构造函数时,子类必须手动通过super或者this语句形式来指定要访问的构造函数。
子类中至少会有一个构造函数会访问父类中的构造函数。
final关键字
final:最终的,作为一个修饰符;可以修改类、函数、属性。
被final修饰的类不可以被继承。
被final修饰的函数不能被复写。
被final修饰的变量是一个常量只能被赋值一次,既可以修饰成员变量,又可以修饰局部变量。
描述事物时,一些数据的出现时固定的,那么这时为了增强阅读性,都给这些值取个名字。方便于 阅读,而这个值不需要改变,所以加上final修饰;作为常量。
抽象类
当多个类中出现相同功能,但是功能主题不同,这时我们可以抽取功能定义来形成抽象类,而不抽取功能主体。
//定义一个抽象类
public abstract class Student{
abstract void study();
}
//定义一个继承抽象类的子类
public class BaseStudent extends Student {
//复写父类的抽象方法
void study() {
System.out.println("base study");
}
}
抽象类的特点:
1、抽象方法一点光在抽象类中;
2、抽象方法和抽象类都必须被absstract关键字修饰;
3、抽象类不可以创建对象,因为调用抽象方法没有意义;
4、抽象类中的抽象方法要被使用,必须由子类复写其所有的抽象方法后,建立子类对象。如果子类对象只覆盖
了部分抽象方法;那么该子类还是一个抽象类。
抽象类和一般类没有太大不同;该如何描述事物就如何描述事物,只不过该事物出现了一些抽象的方法。
这些抽象的部分,也是该事物的功能,需要明确出现,但无法定义主体;通过抽象方法来实现。
抽象类比一般类多了抽象方法(就是在类中定义抽象方法)。
切记抽象类不可以被实例化。
抽象类中可以不定义抽象方法,这样做只是为了不让该类建立对象。
抽象类具体应用示例:
//定义一个抽象员工类 包含员工的基本信息
public abstract class Employee {
private String name;
private double sal;
//基本员工类构造函数
public Employee(String name, double sal) {
this.name = name;
this.sal = sal;
}
//定义一个抽象的work方法
public abstract void work();
}
//普通员工类继承基本员工类
public class BaseEmp extends Employee {
//普通员工类的构造方法,直接调用父类的属性值
public BaseEmp(String name, double sal) {
super(name, sal);
}
//重写work方法
public void work() {
System.out.println("baseEmployee work");
}
}
//经理类继承基本员工类
public class Manager extends Employee {
//子类自己的属性
private int bonus;
//子类的构造方法,父类有的属性直接调用腹泻的
public Manager(String name, double sal, int bonus) {
super(name, sal);
this.bonus = bonus;
}
//重写work方法
public void work() {
System.out.println("manager work");
}
}
接口
interface用于定义接口;
接口定义时:
1、接口中常见的定义:常量、抽象方法。
2、接口中的成员都有固定修饰符;
常量:public static final
方法:public abstract
接口中的成员都是public的。
接口是不能创建对象的,因为有抽象方法。需要被子类实现,子类对接口中德抽象方法全部覆盖,子类才可能实例化,
否则子类是个抽象类。
//定义一个借口
interface A{
public static final int NUM=0; //接口的属性会被public static final修饰
public abstract void show(); //定义一个抽象方法会被public abstract修饰
}
//定义一个类实现A接口
public class B implements A{
//复写A接口的show方法
public void show() {
}
}
接口可以被类多实现;是对多继承的不支持的转换形式。
接口可以多继承。
接口与接口之间是继承关系,而且,接口与接口直接可以多继承。
interface A{
public abstract void show();
}
interface B{
public abstract void show1();
}
public class C{
}
//定义一个类实现A接口和B接口并继承C类
public class D extends C implements A,B{
//复写A接口的show方法
public void show() {
}
//复写B接口的show1方法
public void show1() {
}
}
接口的特点:
1、接口是对外暴露的规则。
2、接口是功能的特点。
3、几口可以用俩实现。
4、类与接口之间是实现关系,而类可以在继承一个类的同时实现多个接口。
5、接口与接口之间可以有几场关系。
总之:基本功能定义在类中,扩展功能定义在接口中!