方法重写 多态 抽象类 接口 final关键字

方法重写概述及其应用

•方法重写是指子父类出现了一模一样的方法

•重写这个概念只是存在子类和父类中

 

方法重写的应用

•当子类需要父类的功能，而子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。

 

动物都会走，但走的方式不同

class test  
{
	public static void main (String[] args)
	{
		dog d = new dog();
		d.walk();
		chiken c = new chiken();
		c.walk();
	}
}


class animal{
    public void walk(){};
}

class dog extends animal{
    public void walk(){
        System.out.println("狗四条腿走");
    }
}

class chiken extends animal{
    public void walk(){
        System.out.println("鸡两条腿走");
    } 
}

方法重写的注意事项

父类中私有方法不能被重写,因为父类私有方法子类根本就无法继承

子类重写父类方法时，访问权限最好就一致

 

方法重写重载的面试题

 Overload能改变返回值类型吗?

①overload是指方法重载，重载可以改变返回值类型,方法的重载只看参数列表不同

 

Override重写和Overload重载的区别?

①Override是指方法重写，也就是子类中出现了和父类中方法声明一模一样的方法。

②方法的重写是与返回值类型有关,返回值是一致(或者是子父类)的

③方法重载：本类中出现的方法名一样，参数列表不同的方法。与返回值类型无关。 

 

方法重载：

class test  
{
	public static void main (String[] args) 
	{
		Animal dog = new Animal();
		dog.walk(4);
		Animal fish = new Animal();
		fish.walk("不会走");
	}
}

class Animal {
     public void walk(int legs){
        System.out.println("我有" + legs + "条腿");
    }
    public void walk(String s){
        System.out.println(s);
    }
}

 

final关键字修饰类,方法以及变量的特点

final修饰特点

①修饰类，类不能被继承，相当于做了丁克

②修饰变量，变量就变成了常量，只能被赋值一次

③修饰方法，方法不能被重写

 

●修饰变量

①final修饰变量叫做常量,一般会与public static共用

②常量命名规范,如果是一个单词,所有字母大写,如果是多个单词,每个单词都大写,中间用下划线隔开,如 public static final MAX_AGE  = 125;

 

final修饰局部变量特性

①修饰基本类型，是值不能被改变

②修饰引用类型，是地址值不能被改变,对象中的属性可以改变

③修饰引用类型不可以再New

 

final修饰变量的2个初始化时机

①一定义变量可以初始化【这种初始化方法比较常用】

②在构造方法初始化

●注意：在类中不可重复给final赋值，只能赋值一次

 

多态的概述：

 

Java中存在多态的前提条件

要有继承关系

要有方法重写

要有父类引用指向子类对象

 

多态中的成员访问特点

成员变量：编译看左边(父类)，运行看左边(父类)

成员方法：编译看左边(父类) ，运行看右边(子类)

静态方法：编译看左边(父类) ，运行看左边(父类)

总结:只有非静态的成员方法，编译看左边，运行看右边

 

 

多态中向上转型和向下转型

 

向上转型：父类指向子类对象 Person p = new SuperMan();

向下转型：子类指向父类对象 SuperMan sm = (SuperMan)p;

向下转型注意:父类的真实对象必须是子类对象,否则会有问题

 

多态的好处和弊端

好处:

提高了代码的维护性(继承保证)

eg:在父类改一个属性不用每个子类都改属性

提高代码的扩展性(多态保证)

    eg:方法中使用父类为参数，来实现方法或者属性的调用

弊端

不能使用子类的特有属性和行为

多态注意事项

开发中创建对象的时候用父类引用指向子类对象比较常用

当作参数时候使用多态最好，因为扩展性强

 

多态练习：

public class Demo2 {
	public static void main(String[] args) {
		A a = new B();
		a.show();
		B b = new C();
		b.show();
	}
}
class A{
	public void show(){
		show2();
	}
	public void show2(){
		System.out.println("我");
	}
}
class B extends A{
	public void show2(){
		System.out.println("爱");
	}
}
class C extends B{
	public void show(){
		super.show();
	}
	public void show2(){
		System.out.println("妳");
	}
}


// 结果“爱你”

多态调用方法执行的效果是看右边

 

抽象类的概述及特点：

抽象类:可以理解为看不懂的类

抽象类的特点

a)抽象类和抽象方法必须用abstract关键字修饰

•abstract class 类名{}

•public abstract void eat();

b)抽象类不一定有抽象方法，有抽象方法的类一定是个抽象类或者是接口

c)抽象类不能实例化，那么如何进行抽象类实例化？

•由具体的子类实例化。其实这也是多态的一种，抽象类多态

d)抽象类的子类

•要么是抽象类

•要么重写抽象类中的所有抽象方法

 

 

抽象类成员的特点

成员变量:即可以是变量，也可以是常量。

abstract不能修饰成员变量，只能修饰类和方法

构造方法:抽象类也是有构造方法的，用于子类访问父类数据的初始化

成员方法:抽象类的方法可以是抽象的，也可以是非抽象

抽象类的成员方法特性:

抽象方法：强制要求子类实现

非抽象方法：子类继承实现自己的业务，提高代码的复用性

 

1.一个抽象类如果没有抽象方法，可不可以定义为抽象类？如果可以，有什么意义

可以，这么做的目的只有一个，就是不让其它类创建本类对象，交给子类完成

2.abstract不能与哪些关键字共存

abstract和static

 1.static修饰的方法是通过类名来调用

 2.abstract修饰的方法必须由子类来实现，并由子类对象来调用方法

 3.对象方法与类方法是冲突的

abstract和final

1.final修饰的方法是不能被重写的，所以也矛盾

abstract和private

1.private修饰的方法不让子类访问，所以也矛盾

 

接口的概述及其特点

接口概述：

•从狭义的角度讲就是指java中的interface

•从广义的角度讲对外提供规则的都是接口

•接口就是提供对外访问的规则

接口的特点

a:接口用关键字interface表示

  interface 接口名{}

b:类实现接口用implements表示

  class 类名 implements 接口名{}

c:接口不能实例化

  按照多态的方式来实例化

d:接口的子类

  可以是抽象类，但意义不大

  可以是具体类，要重写接口中的所有方法

import java.io.*;
class test  
{
	public static void main (String[] args) throws java.lang.Exception
	{
        Cat cat  = new Cat();
        cat.eat();
        cat.say();
	}
}


interface Animal{
    public void eat();      //接口声明的方法均为抽象方法 
    public void say();
}

class Cat implements Animal{
    public void eat(){
        System.out.println("吃鱼");
    }
    public void say(){
        System.out.println("喵喵");
    }
}

 

类与类，类与接口，接口与接口的关系

类与类:

继承关系，只能是单继承，可以多层继承

类与接口

实现关系，可以单实现，也可以多实现

并且还可以在继承一个类的同时实现多个接口

接口与接口

继承关系，可以单继承，也可以多继承

 

抽象类与接口的区别

A.成员区别

抽象类:

*成员变量：可以变量，也可以常量

*构造方法：有

*成员方法：可以抽象，也可以非抽象

接口：

*成员变量：只可以常量

*成员方法:只可以抽象

B.关系区别

类与类:  继承关系，单继承

类与接口:   实现关系，单实现和多实现都可以

接口与接口: 继承关系，单继承和多继承

C.设计理念区别

           抽象类 抽象类中定义的是该继承体系的共性功能

            接口 接口中定义的是该继承体系的扩展功能