狂神说Java
面向对象15：抽象类
package oop.demo08;
//abstract 抽象类
public abstract class Action {
//约束~ 有人帮我们实现~
//abstract, 抽象方法，只有方法名字，没有方法的实现
public abstract void doSomething();
}
package oop.demo08;
//抽象类的所有方法，继承了它的子类，都必须要实现它的方法
public class A extends Action{
@Override
public void doSomething() {
}
}
总结：
1、不能new这个抽象类，只能靠子类去实现它：约束！
2、抽象类中可以写普通的方法
3、抽象方法必须在抽象类
面向对象16：接口的定义与实现
接口的本质是契约。
package oop.demo09;
public interface UserService {
//接口中的所有定义其实都是抽象的 public abstract;
public abstract void run();
}
package oop.demo09;
//interface 定义的关键字
public interface UserService {
//常量 public static final
int AGE = 99;
//接口中的所有定义其实都是抽象的 public abstract;
void add(String name);
void delete(String name);
void apdate(String name);
void query(String name);
}
package oop.demo09;
//抽象类：extends
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法
public class UserServiceImpl implements UserService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void apdate(String name) {
}
@Override
public void query(String name) {
}
}
可以利用接口实现多继承
作用：
1、约束
2、定义一些方法，让不同的人实现
3、方法都是public abstract
4、属性都是 常量 public static final
5、接口不能被实例化 接口中没有构造方法
6、implements 可以实现多个接口
7、继承接口的类，必须要重写接口中的方法
面向对象17：N种内部类
package oop.demo10;
public class Outer {
private int id;
public void out(){
System.out.println("这是外部类的方法");
}
public class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
}
}
package oop;
import oop.demo10.Outer;
public class Application {
public static void main(String[] args) {
//new
Outer outer = new Outer();
//通过这个外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();
}
}
一个java类中可以有多个class类，但是只能有一个public class
