1.抽象类
加了abstract就变成了抽象类抽象类中可以写普通的方法
特点:
1.不能new这个抽象类,只能靠子类去实现它;约束
2.抽象类中可以写普通的方法
3.抽象方法必须在抽象类中
抽象的抽象:约束
存在的意义:抽象出来~ 提高开发效率
//abstract 抽象类:本质上还是类。Java的类是单继承的,extends:单继承 (接口可以多继承)
public abstract class Action {
//约束~有人帮我们实现~
//abstract,抽象方法,只有方法名字,没有方法的实现!
public abstract void doSomething();
}
//抽象类的所有方法,继承了它的子类,都必须要实现它的方法,除非它的之类也是abstract
public class A extends Action {
@Override
public void doSomething() {
}
}
2.接口
1.接口只有方法的定义,通过interface来定义,定义完之后,子类要去实现它,通过implements关键字实现了接口之后,重写了里面的方法。
2.接口就相当于一个约束
接口中的方法:
//interface 定义的关键字 。接口都需要有实现类
public interface UserService {
//接口中的所有定义的方法其实都是抽象的 public abstract
public abstract void add(String name);//接口可以这样子写:返回值类型+方法名,括号里可以加个参数
void delete(String name);
void update(String name);
void query(String name);
}
public interface TimeService {
void timer();
}
//抽象类: extends 单继承
//类 可以实现接口 implements 借款
//要实现了接口的类,就需要重写接口中的方法
//多继承 利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
在接口中定义的属性都是常量(一般不这样操作)
修饰:public static final
作用:
1.约束
2.定义一些方法,让不同的人实现。
3.方法定义: public abstract
4.常量定义:public static final
5.接口不能被实例化,因为接口中没有构造方法
6.接口可以通过implements方法,实现多个接口
7.必须要重写接口中的方法```
3.内部类
1.成员内部类
- 在类的内部定义,与实例变量、实例方法同级别的类。。
- 外部类的一个实例部分,创建内部类对象时,必须依赖外部类对象。
2.局部内部类
- 定义在外部类方法中,作用范围和创建对象范围仅限于当前方法。
3.静态内部类
- 不依赖外部类对象,可直接创建或通过类名访问,可声明静态成员。
- 只能直接访问外部类的静态成员(实例成员需实例化外部类对象)。
4.匿名内部类
- 没有类名的局部内部类(一切特征都与局部内部类相同)。
//外部类
public class Outer {
//实例变量
private String name = "hjx";
private int age = 18;
//内部类
class Inner{
private String address = "北京";
private String name = "xjh";
//方法
public void show(){
//内部类属性和外部类的属性相同时,打印外部类的属性,用Outer.this
System.out.println(Outer.this.name); //hjx
//打印内部类的属性
System.out.println(this.name); //xjh
}
}
}
public class Application {
public static void main(String[] args) {
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.show();
}
}
//外部类
public class Outer {
//实例变量
private String name = "hjx";
private int age = 18;
//静态内部类,和外部类相同
static class Inner1{
private String address = "上海";
//静态成员
private static int count = 100;
public void show(){
//调用外部类的属性
//1.先创建外部类对象
Outer outer = new Outer();
//2.调用外部类的属性
System.out.println(outer.name); //hjx
System.out.println(outer.age); //18
//调用静态内部类的属性和方法
System.out.println(address); //上海
//调用态内部类的的静态属性
System.out.println(Inner1.count); //100 静态成员通过(类名.变量)访问
}
}
}
public class Application {
public static void main(String[] args) {
//直接创建静态内部类对象
Outer.Inner1 inner1 = new Outer.Inner1();
//调用方法
inner1.show();
}
}
public class Outer {
private int id = 10;
public void out(){
System.out.println("这是外部类的方法");
}
public class Inner{
public void in(){
System.out.println("这是内部类的方法"); //这是内部类的方法
}
//获得外部类的私有属性
public void getId(){
System.out.println(id); //10
}
//局部内部类
public void method(){
class Inner1{
}
}
}
//一个Java类中可以有多个class类,但是只能有一个 public class
class A{
}
}
public class Application {
public static void main(String[] args) {
//外部类通过new关键字来实现
Outer outer = new Outer();
//通过外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();
inner.getId();
}
}
public class Test {
public static void main(String[] args) {
Apple apple = new Apple();
/*new一个Apple,这个Apple的名字是apple,
实例化了这个对象,并且把这个对象赋值给了apple。对象名:apple
*/
//匿名内部类:没有名字初始化类,不用将实例保存到变量中
new Apple().eat(); //匿名对象的使用
new UserService(){ //这个方法会返回一个userService对象,但是它没有名字。
//这个类就是实现了接口的类,这个类也没有名字
//要重写里面的方法
@Override
public void hello() {
}
};
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
//接口
interface UserService{
void hello();
}