Java重写和重载
重写是子类对父类允许访问的方法进行重新编写,返回值和形参不能变。
即外壳不变核心重写
方法重写 的规则:
1.参数列表必须与被重写方法完全相同
2.返回值类型可以不同,但必须是父类方法返回值的派生类
3.访问权限不能比父类被重写的方法权限低
4.父类成员方法只能被子类成员重写
5,final方法不能被重写
6.static不能被重写,但可以被重新声明
7,构造方法不能被重写
当需要在子类中调用父类的被重写方法时,要用super关键字
```java
package java学习.重写和重载;
class Animal{
public void move(){
System.out.println("动物可以移动");
}
}
class Dog extends Animal{
public void move(){
super.move();//应用super类
System.out.println("狗可以跑");
}
}
public class Override {
public static void main(String[] args) {
Animal a = new Animal();
a.move();
System.out.println();
Dog c = new Dog();
c.move();
System.out.println();
Animal b = new Dog();
b.move();
}
}
重载:是一个类里面,方法名字相同,参数不同,返回值不同
每个重载的方法必须有独一无二的参数列表
最常用的是构造器重载
重载的规则:
1.被重载的方法 必须 改变参数列表(个数或类型不一样)
2. 被重载的方法可以改变返回类型
3,被重载的方法可以改变访问修饰符
4,被重载的方法可以声明新的或更广的检查异常
5.方法能在一个类,或一个子类中被重载
package java学习.重写和重载;
public class Overloading {
public int test(){
System.out.println("test1");
return 1;
}
public void test(int a){
System.out.println("test2");
}
public String test(int a ,String s){
System.out.println("test3");
return "resulttest3";
}
public String test(String s,int a){
System.out.println("test4");
return "resulttest4";
}
public static void main(String[] args) {
Overloading o = new Overloading();
System.out.println(o.test());
System.out.println();
o.test(1);
System.out.println();
System.out.println(o.test(1,"test3"));
System.out.println(o.test("test4",1));
}
}
Java多态
多态是:同一个行为有多个不同表现形式或形态
多态就是一个接口,使用不同实例执行不同操作
多态的优点:
1.消除类型之间的耦合关系
2.可替换性
3.可扩充性
4.接口性
5.灵活性
6.简化性
多态存在的三个必要条件:
1.继承
2.重写
3.父类引用指向之类对象 Parent p = new Child();
package java学习.多态;
public class Variety {
public static void main(String[] args) {
show(new Cat());
show(new Dog());
Animal a = new Cat();
a.eat();
Cat c = (Cat) a;
c.work();
}
public static void show(Animal a) {
a.eat();
if (a instanceof Cat) {
Cat c = (Cat) a;
c.work();
} else if (a instanceof Dog) {
Dog c = (Dog) a;
c.work();
}
}
}
abstract class Animal{
abstract void eat();
}
class Cat extends Animal{
@Override
public void eat() {
System.out.println("吃鱼");
}
public void work(){
System.out.println("抓老鼠");
}
}
class Dog extends Animal{
@Override
void eat() {
System.out.println("吃骨头");
}
public void work(){
System.out.println("看门");
}
}
Java抽象类
抽象类不能实例化对象,所以抽象类必须被继承,才能使用。(因此在SEI阶段决定不要使用抽象类)
Java中抽象类表示的是一种继承关系,一个类只能继承一个抽象类,但一个类可以实现多个接口
package java学习.抽象类;
public abstract class Employee {
private String name;
private String address;
private int number;
public Employee( String name,String address,int number){
System.out.println("Constructing an Employee");
this.name = name;
this.address = address;
this.number = number;
}
public double computePay(){
System.out.println("Inside Employee computePay");
return 0.0;
}
public void mailCheck(){
System.out.println("Email is check to " + this.name +" "+ this.address);
}
public String toString (){
return name+" "+address+" "+number;
}
public String getName() {
return name;
}
public String getAddress() {
return address;
}
public void setAddress(String newAddress) {
address = newAddress;
}
public int getNumber() {
return number;
}
}
package java学习.抽象类;
public class Salary extends Employee {
private double salary;
public Salary(String name, String address, int number,double salary) {
super(name, address, number);
setSalary(salary);
}
public void mainCheck(){
System.out.println("Within mainCheck of Salary class ");
System.out.println("Mailing check to " + getName()+ "with salary "+ salary);
}
public double getSalary() {
return salary;
}
public void setSalary(double newSalary) {
if (newSalary>=0.0){
salary = newSalary;
}
}
public double computePay(){
System.out.println("Computing salary pay for "+ getName());
return salary/52;
}
}
package java学习.抽象类;
public class AbstractDemo {
public static void main(String[] args) {
//Employee e = new Employee("ZHANGYANA ","CAIHU",43) ;
/**
* 抽象类不可初始化
*/
Salary s = new Salary("tt","usa",4,5300.00);
Employee e = new Salary("张亚楠","美国",3,5300.00);
System.out.println("Call mainCheck using Salary refercence --");
s.mainCheck();
System.out.println("\n Call mainCheck using Empolyee refercence -- ");
e.mailCheck();
}
}
Java接口
接口是Java编程语言中的一个抽象类型,是抽象方法的集合。
一个类通过继承方法的方式,从而继承接口的抽象方法。
类描述对象的属性和方法
接口则包含类要实现的方法
除非实现接口的类是抽象类,否则该类要定义接口的所有方法。
接口不能实例化,但可以被实现。
Java中接口类型可以用来声明一个变量,他们可以成为一个空指针,或者是被绑定的在一个以此接口实现的对象
接口的实现
package java学习.接口;
public interface Animal {
public void eat();
public void travel();
}
package java学习.接口;
public class MammalInt implements Animal{
@Override
public void eat() {
System.out.println("Mammal eats");
}
@Override
public void travel() {
System.out.println("Mannal travel");
}
public int noOfLegs(){
return 0;
}
public static void main(String[] args) {
MammalInt m = new MammalInt();
m.eat();
m.travel();
}
}
接口的继承
package java学习.接口;
public interface Sports {
public void setHomeTeam(String name);
public void setVisitingTeam(String name);
}
package java学习.接口;
public interface Football extends Sports {
public void homeTeamScored(int points);
public void visitingTeameScored(int points);
public void endOdQuarter(int quater);
}
package java学习.接口;
import org.w3c.dom.events.Event;
public interface Hockey extends Sports, Event {//接口允许多继承,类不允许多继承
public void homeGoalScored();
public void visitingGoalScored();
public void endOfPeriod(int period);
public void overtimePeriod(int ot);
}
标记接口
package java学习.接口;
public interface EventListener {
/**
* 没有任何方法的接口称为标记接口
* 建立标记接口的目的:
* 1、建立公共的父接口
* 2、向一个类添加数据类型
*/
}