1、继承 extends
子类构造方法中,编译器调用父类的无参构造方法,所以子类的构造方法中的super()可省略。
当父类只有有参构造方法,而子类调用父类构造,编译器只能调用有参的,则super(xxx)不可省略。
java不支持多继承(菱形继承问题,比如类A,B是继承了Object类,类C继承了A,B类,但A,B类中有同名方法,现在就不知道到底调用的是哪个方法了 为了避免 java不支持多继承。为了弥补,Java的接口可以多实现)
2、super关键字的使用
1 用于从派生类访问基类的成员
2 派生类要调用基类的构造方法 super(),super()只能在派生类的构造方法中调用,位于方法首行。
3 调用基类已被其他方法重写的方法
4 访问基类的数据成员:super.成员变量、super.成员方法
3、成员变量的隐藏和方法的覆盖
类方法的重写应满足下列条件:
1 派生类中该方法的返回值和基类同名方法的返回值相同,参数列表相同。
2 派生类中的重写方法的访问权限不能比基类小。权限的顺序为:public,protected,private。
3 基类的 abstract 方法必须被派生类重写,否则派生类也必须是 abstract
4 基类的 final 方法不能被派生类重写。
class Animal{
protected String name;
protected int age;
protected String sex;
Animal(){};
public Animal(String name){
this.name =name;
}
public void eat(){
System.out.println("Animal eat");
}
}
class Cat extends Animal{
protected String name;
public void eat(){//覆盖父类的方法
System.out.println("Cat eat");
}
public void catMice(){
System.out.println(super.name);//访问父类的成员变量
super.eat();//访问父类中的方法
System.out.println(name+"catMice");
}
}
4、抽象
1、抽象类和抽象方法
抽象类:在 Java 面向对象当中,所有的对象都是用过类进行描绘的,但是并不是所有的类都是用来描绘对象的,如果一 个类中没有包含足够的信息来描绘一个具体的对象,我们把这种类定义为抽象类。
抽象类的特征:
1、不能用来实例化对象,所以抽象类必须被继承才能被使用,其他功能和普通类相似。
2、一个抽象类只能继承一个抽象类。
3、抽象类的修饰符不能是private。
抽象方法:如果想要设计一个类,该类包含一个特别的成员方法,该方法是根据子类的行为来确定的,那么在父类中将这个方法声明为抽象方法。继而含有抽象方法的类称为抽象类。
抽象方法的特征:
1、抽象类不一定含有抽象方法,但有抽象方法的类一定是抽象类。
2、构造方法,类方法(static修饰的方法)不能声明成抽象方法。
3、抽象类的子类必须给出抽象类中抽象方法的实现,除非该子类也是一个抽象类。
4、抽象方法的修饰符不能是private。
abstract class Empployee{
private int age;
private String address;
private int num;
public Empployee(int age, String address, int num) {
this.age = age;
this.address = address;
this.num = num;
}
public void mailCheck(){
System.out.println("mailng a check to"+this.age+""+this.address);
}
public void setAddress(String newaddress){
this.address=newaddress;
}
public abstract void fun();//定义抽象方法
}
class ExtendEmployee extends Empployee{
public ExtendEmployee(int age, String address, int num) {
super(age, address, num);
}
public void fun(){//抽象类方法的实现
System.out.println("实现了抽象方法");
}
}
public class AbstractClass {
public static void main(String[] args) {
// Empployee empployee = new Empployee();抽象类不能被实例化
}
}
5、接口
抽象类中,可以包含一个或多个抽象方法,但在接口中,所有的方法必须是抽象的,不能有方法体。抽象类比接口更抽象。接口规定一个类必须做啥,但不规定怎么去做。
接口中声明的成员变量默认是 public static final,必须是显式的初始化。因而在常量声明时,可以省略这些修饰符。是若干常量和抽象方法的集合。
5.1接口性质:
1、接口中只定义抽象方法,这些方法默认是public abstract的,在声明的时候可以省略这些修饰符。
2、接口中定义实例变量,非抽象实例方法以及静态方法都是不允许的。
3、接口中没有构造方法,也不能被实例化。
4、一个接口不能实现另一个接口,但可以多继承其他接口。
5.2 接口的使用:
1、接口的使用与类的使用不同,在需要使用类的地方,会直接进行new关键字来创建一个类的实例,但接口不行。
2、接口必须通过类来实现他的抽象方法。
3、如果一个类不能实现完接口中的抽象方法,那这个类应该设计为抽象类。
4、不允许创建接口的实例,但允许定义接口类型的引用变量 引用实现该接口的类的实例。
interface InterfaceClass{
int a = 10;//必须是public finaal int a =10;只是省略 必须进行初始化
void fun();//public abstract fun() 只能用public abstract修饰,不能用其他
}
class AchieveInterface implements InterfaceClass{
public void fun(){
System.out.println("achieve interface abstract method");
}
}
6、向上造型
向上造型就是定义父类的引用,引用派生类的对象。
Animal animail = new Cat();
animal引用.出来的方法是父类的方法接口,但是方法的实现却是子类的实现方式。
6、1接口的使用
interface Fruit{
public abstract void eat();
}
class Apple implements Fruit{
public void eat(){
System.out.println("吃苹果");
}
}
public class InterfaceCla {
public static void main(String[] args) {
Fruit f = new Apple();
f.eat();
}
}
本程序在主类中通过 Apple 类实例化 Fruit 接口对象,通过接口对象调用 eat 方法,调用的是被重写过的方法。 本程序在接口的实例化中明确要调用的子类对象。但是,一个父类所派生出来的子类不止一个。Class Orange implements Fruit{}. main: Fruit f=new Orange();难道每一次都要修改实例化接口的子类吗? 在 Java 中的 JVM 为了解决程序与操作系统之间的耦合问题,在程序与操作系统之间加了一个中间过渡层-JVM,由 JVM 匹配不同的操作系统,只要 JVM 核心不变,程序就可以在任意的操作系统间进行移植。 想办法只让用户看到接口而不必看到子类: 添加一个工厂类进行过渡
class Factory{
public static Fruit getInstance(String className){
If(className.equals(“apple”)){
Return new Apple();
}
If(className.equals(“orange”)){
Return new Orange();
}
}
}
Main:
Fruit f=Fruit.getInstance(“apple”);
f.eat();
7、多态的实现原理
7、1发生多态的三个条件
1、继承
2、方法的重写
3、父类引用派生类对象(向上构型)
abstract class Shape{
protected int wide;
protected int length;
protected int high;
public Shape(int wide, int length, int high) {
this.wide = wide;
this.length = length;
this.high = high;
}
public Shape(){};
public abstract double CirCumference();//周长
}
class Rectangle extends Shape{
public Rectangle(int wide, int length, int high) {
super(wide, length, high);
}
public Rectangle(){};
@Override
public double CirCumference() {
return 2*(this.high+this.length+this.wide);
}
}
class Square extends Shape{
public Square(int wide, int length, int high) {
super(wide, length, high);
}
public Square() {
}
@Override
public double CirCumference() {
return 4*this.wide;
}
}
public class TestDemo {
public static void main(String[] args) {
Shape rec = new Rectangle(10,23,90);//父类定义子类对象 向上造型
System.out.println(rec.CirCumference());
Square squa = new Square(10,10,10);
System.out.println(squa.CirCumference());
}
}
7.2 动多态(运行时多态)
运行期
注意:发生运行时多态的三个条件。
7.3 静多态
静多态称编译时多态,就是所说的方法的重载。相同的函数名,根据形参个数的不同调用
调用不同的方法。在编译期就已经确定要调用的方法。
7.4 重写和重载的区别:
1、所处的作用范围不同。重载是在同一个类中进行方法的定义,重写是在父子类中进行方法的定义。
2、其次,他们的定义方式不同。重载是方法名同,参数列表不同。而重写是方法名,参数列表相同。