继承接口的理解以及实现

1.构造函数

定义：用于构造对象对象的一种行为

格式：public 类名(){}

什么时候执行：创建当前类的对象的时候，自动执行

注意：1.除了接口类之外所有类都会有构造方法

            2.构造方法有返回值，返回的是对象在内存中的地址

为了理解构造方法返回的是对象在内存中的地址，我敲了下面的代码

Teacher类，定义了name属性和构造函数

package Example01;
public class Teacher {
public String name;
public Teacher(){
}
}

测试类，我创建了3个对象t1,t2,t3；把t1地址传给t3,再把t2地址传给t1，观察输出的值

package Example01;
public class Test {
public static void main(String[] args) {
Teacher t1=new Teacher();
Teacher t2=new Teacher();
Teacher t3=new Teacher();
t1.name="张三";
t2.name="李四";
t3=t1;
t1=t2;
t1.name="王五";
System.out.println(t1.name);
System.out.println(t2.name);
System.out.println(t3.name);
}
}

最终输出结果是：

王五

王五

张三

2.方法重载

定义：同一个类中，多个方法的方法名相同，参数列表不同（类型、顺序、个数）的方法互为重载方法

分类：普通方法重载和构造方法重载

构造方法重载作用：可以初始化当前对象的一些属性

注意：一旦你重载了构造方法后，则默认的那个没有参数的构造方法就消失了

     如果还需要用无参的构造方法，则需要显性定义出来

这次我做了2个类，一个Play类和一个测试类，在play类中我创建了构造函数，并重载了函数，然后在测试类中创建了对象，观察输出结果

Play类

package Example02;
public class Play {
public Play(){
System.out.println("构造函数出击");
}
public Play(int a){
System.out.println("带数字的重构函数出击");
}
public Play(String b){
System.out.println("带字符串的重构函数出击");
}
}

测试类

package Example02;
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
Play p1=new Play(3);
Play p2=new Play("aaa");
Play p3=new Play();
}


}

输出：

带数字的重构函数出击
带字符串的重构函数出击
构造函数出击

3.继承，方法重写和多态

我根据 继承 -> 方法重写和自动转型— > 多态性，决定把两个放在一个代码中，从而来体现出他们的相关性

继承：

package Example04;


public class Test {


public static void main(String[] args) {
Worker w=new Worker();
w.CleanDoors();
w.CleanWindows();


}


}

定义：子类继承父类的属性和方法（构造方法不能继承）

格式：public class 子类类名  extends  父类类名{}

注意：任何一个类都是Object类的子类

      继承只能是单继承，不能是多继承，但是可以多层继承

方法重写格式：子类重写父类的方法，方法名、参数列表、返回类型必须都要一样的

自动转型格式：子类对象自动转型为父类的类型

              父类类型  对象名=  new  子类类型();

注意：自动转型后的对象，如果子类重写了父类的方法，则执行的是重写后的

多态：多个同一个类型的对象，执行同一个方法，过程不一样就是多态性

代码思想：我准备创建4个类，一个父类，二个子类，其中一个子类对父类的方法进行了重写，一个测试类，测试类中使用了自动转型格式，由于一个子类重写了方法，导致虽然执行同一个方法，但过程不一样，体现出多态性。

父类：package Example03;
public class Father {
public void play(){
System.out.println("小明最喜欢踢足球");
}
}

子类1：package Example03;
public class Child extends Father{

}

重写了方法的子类2：

package Example03;
public class Son extends Father{

public void play(){
System.out.println("小明最喜欢打篮球");
}
}

测试类package Example03;


public class Test {


public static void main(String[] args) {
Father a=new Child();
Father b=new Son();
a.play();
b.play();
}
}

输出结果：

小明最喜欢踢足球
小明最喜欢打篮球

4.方法分类，接口与继承

方法分类：

构造方法：public 类名(){}

普通方法：public 返回类型 方法名(){}

抽象方法：public abstract 返回类型 方法名();

 

普通类：public class 类名{}

1. 方法只能有普通方法和构造方法，一定不能有抽象方法

2. 可以构造对象

抽象类：public abstract class 类名{}

        1. 三种方法都可以存在

2. 不能创建对象

接口：public interface 类名{}

1.只能有抽象方法（可以省略掉中间的abstract修饰词）

        2.不能创建对象

抽象类和接口作用：用于当父类，被继承，约束普通类的成员定义

继承接口：public class 子类类名 implements 接口名{}

注意：接口可以多继承

因为接口抽象类可以用作约束，这次我准备做三个类，一个接口类Boss，它约束了2个方法CleanWindows()和public abstract void CleanDoors();子类Worker类中继承了方法，并在测试类中创建了对象。

Boss类

package Example04;

public interface Boss {
public abstract void CleanWindows();
public abstract void CleanDoors();

}

子类Worker类

package Example04;


public class Worker implements Boss{


public void CleanWindows() {
// TODO Auto-generated method stub
System.out.println("员工打扫了地");
}


public void CleanDoors() {
// TODO Auto-generated method stub
System.out.println("员工擦了门");
}


}

测试类

package Example04;


public class Test {


public static void main(String[] args) {
Worker w=new Worker();
w.CleanDoors();
w.CleanWindows();


}


}

输出结果

员工擦了门
员工打扫了地

个