JAVA接口

、

1. 继承：

代码利用的方式，子类与父类之间的关系

语法

访问控制修饰符 class 类名 extends 父类名{

}

 

访问控制修饰符：public protected default private

规则：

• 同一个包类，子类可以得到父类private(私有)之外的所有属性和方法
• 在不同的包内，子类只可以得到父类public修饰的属性和方法

 java类的祖先：Object

• • equals():比较地址是否相同
  • hasCode():
  • toString():输出类句@16进制的哈希值

1. 重写：

子类覆盖父类同名的方法

final关键字：不可变

public static final PAGE_SIZE = 18;

final修饰的类不能作为父类被子类继承

1. 多态：

多种形态：随着父类/接口指针指的不同，同一段代码执行时呈现出不同的结果

一、接口

    作用：用来定义规则。

    

    注意：

• 接口中所有东西全部都是public(公共) 的
• 对于   常量    系统会  默认  加上public static final
• 对于    方法申明   系统会  默认  加上public abstract
• 接口实验类    不能  从接口中得到  静态方法
• 接口实验类    可以  从接口中得到  默认方法
• 静态方法  只能  通过接口的名称来访问

接口用来定义语法规则，让别的类实现

        语法：

控制修饰符 class 类名 implements 接口名{

        //接口中抽象方法的实现

}

eclipse源代码：

package day10;
public class 接口 {
//定义接口
 public interface Traffic{
 public static final int sits = 4;
 public abstract void run();
 public abstract void stop(); 
}
//调用接口
 public class bwm implements Traffic{
  
  @Override
 public void run() {
   System.out.println("bwm:500km/h");
  }
  @Override
  public void stop() {
   System.out.println("bwm:10m");
  }
 }
 
}
package day10;
import day10.接口.Traffic;
//测试：
public class 接口的测试类 {
public static void main(String[ ] args) {
 Traffic traffic;
 traffic = new cat();
 System.out.println(traffic.sits);
 traffic.run();
 traffic.stop();
}
}
示例：
public interface Traffic {
 public static final int SEATS = 5;
 public abstract void run();
 public abstract void brake();
 
 static void fun1() {
  System.out.println("static");
 }
 
 default void fun2() {
  System.out.println("default");
 }
}
public static void main(String[ ] args) {
 Traffic.fun1();
 
 Traffic traffic = new BWM();
 traffic.fun2();
 //traffic.fun1();
 
 BWM bwm = new BWM();
 bwm.fun2()
}

---

抽象类

• • 包含抽象方法的类叫抽象类
  • 抽象类，需要使用    abstract    关键字修饰
  • 抽象类中可以  有普通的方法
  • 抽象类中可以  包含抽象方法
  • 抽象类和普通类唯一的区别：它使用abstract修饰，里面可以有抽象方法。
  • 不能使用抽象类创建对象，即使这个抽象类中没有抽象方法

        示例：

package day10;
public class 抽象类 {
public abstract class AA {
 
 
 private int a;
 private static final int b = 2;
 
 
 static {
 }
 
 {
 }
 public AA() {
 }
 
 abstract void fun();
 
 void fun1() {
 }
 
 public static void main(String[] args) {
  new AA();
 }
}
}

---

内部类：

定义在一个类/方法中的类

public class ABC {
 class A {
}
public void fun() {
 class B{
}
}
}