当前位置：首页 > news >正文

淘客网站自己做b站入口2024已更新

news 2025/7/8 7:52:07

淘客网站自己做,b站入口2024已更新,网站建设与管理书,秦皇岛门户网文章目录抽象抽象的注意事项static\final\private是否可以修饰抽象方法继承和抽象知识点回顾接口接口实现总结抽象方法默认方法静态方法成员变量接口的特点接口和抽象类的区别抽象关键字: abstract 抽象方法: 修饰符 abstract 返回值类型方法名(参数); 抽象类: public a…

文章目录

抽象
- - 抽象的注意事项
  - - static\final\private是否可以修饰抽象方法
    - 继承和抽象知识点回顾
接口
- - 接口实现总结
  - 抽象方法
  - 默认方法
  - 静态方法
  - 成员变量
  - 接口的特点
  - 接口和抽象类的区别

抽象

关键字: abstract
抽象方法:
修饰符 abstract 返回值类型方法名(参数);
抽象类:
public abstract class 类名{ }

public abstract calss pet{String name;/*父类中的方法,我们可以仅仅定义为一个声明,具体的实现交给子类去实现*/public abstract void eat();
}

注意:
a.抽象方法所在的类一定是抽象类
b.抽象类中不一定非得有抽象方法
c.子类继承父类之后,需要重写父类
中所有的抽象方法,不然编译报错
d.抽象类不能new对象,只能通过new子类对象调动重写方法

抽象的注意事项

抽象类不能直接new对象,只能创建非抽象子类的对象
抽象类中不一定非得有抽象方法,但是抽象方法所在的类一定抽象类
抽象类的子类,必须重写父类中的所有抽象方法,否则,编译报错,除非该子类也是抽象类
抽象类中可以有成员变量,构造,成员方法
抽象类中可以有构造方法,是供子类创建对象时,初始化父类属性使用的
抽象类虽然不能被实例化,但是可以通过多态的方法来赋值
作为抽象类的子类

没有抽象方法的抽象类意义是啥?

为了不让外界创建对象,被实例化.

static\final\private是否可以修饰抽象方法

**static和abstract：**是不能够共存的。static是为方便调用，abstract为了给子类重写的，没有方法体
**final和abstract：**是相互冲突的，final修饰的方法不能被重写，而abstract修饰的方法就是为了让子类重写的。
**private和abstract：**也是冲突的，private修饰

继承和抽象知识点回顾

继承:子类继承父类,可以直接使用父类中非私有成员,子类不用写重复性代码
关键字: extends
成员访问特点:
成员变量:看等号左边是谁
成员方法:看new的是谁
方法的重写:子类中有一个和父类从方法名以及参数列表上一样的方法
检测:@Override
使用场景:功能的升级
继承中构造的特点:
new子类对象先初始化父类
super:代表的是父类引用
调用父类构造:super() super(实参)
调用父类成员变量: super.成员变量名
调用父类成员方法:super.成员方法名(实参)

7.this:代表的是当前对象(哪个对象调用的this所在的方法,this就代表哪个对象)

a.作用:区分重名的成员变量和局部变量

b.使用:

调用当前对象构造:this() this(实参)

调用当前对象成员变量:this.成员变量名

调用当前对象成员方法:this.成员方法名(实参)

c.注意:在构造中使用this和super,都必须要在第一行,所以两者不能同时出现

8.继承的特点:

a.继承只支持单继承,不支持多继承

b.继承支持多层继承

c.一个父类可以拥有多个子类

9.抽象:

a.抽象方法: 修饰符 abstract 返回值类型方法名(形参)

b.抽象类:public abstract class 类名{}

c.特点:

抽象方法所在的类一定是抽象类

抽象类中不一定非得有抽象方法

子类继承抽象父类时,需要重写抽象方法

抽象类不能new对象,只能new子类对象

抽象类中啥都可以有,私有属性,构造,其他方法等

抽象类中的构造是供创建子类对象时初始化父类属性使用的

接口

接口是一个引用数据类型

关键字:

interface接口
```
public interface 接口名{ }
```
implements实现
```
实现类 implements 接口名{ }
```

接口中可以定义的成员:
1. JDK7以及比之前:
  1. 抽象方法
    public abstract ( 即使不写public abstract,默认也有)
  2. 成员变量
    public static final 数据类型变量名 = 值
    (即使不写public static final,默认也有)
    (final是最终的,被final修饰的变量不能二次赋值,所以我们一般将final修饰的变量视为常量)
2. JDK8:
  1. 默认方法
    public default 返回值类型方法名(形参){}
  2. 静态方法
    public static 返回值类型方法名(形参){}
3. JDK9开始:
  1. 私有方法
    1. private的方法(实际开发中用的不是特别多)

接口实现总结

定义接口:public interface 接口名{ }
实现:public class 实现类类名 implements 接口名{ }
使用方法:
1. 实现类实现接口
2. 重写接口中的抽象方法
3. 创建实现类对象(接口不能new对象)
4. 调用重写的方法

//接口实现代码案例
public interface USB {	//定义接口public abstract void open();public abstract void close();
}public class Mouse implements USB{	//定义接口实现类@Overridepublic void open() {System.out.println("鼠标打开");}@Overridepublic void close() {System.out.println("鼠标关闭");}
}public class Test01 {	//测试类public static void main(String[] args) {Mouse mouse = new Mouse();mouse.open();mouse.close();}
}

抽象方法

定义格式:public abstract 返回值类型方法名(形参)
注意事项:不写public abstract默认也是有的
使用方法:
1. 定义实现类\实现接口
2. 需要重写抽象方法
3. 创建实现类对象,调用重写的方法

public interface USB {//定义抽象方法public abstract void open();String close();
}//调用抽象方法制作实现类
public class Mouse implements USB{@Overridepublic void open() {System.out.println("鼠标打开");}@Overridepublic String close() {return "鼠标关闭";}
}public class Test01 {public static void main(String[] args) {Mouse mouse = new Mouse();mouse.open();String result = mouse.close();System.out.println("result = " + result);}
}

默认方法

定义格式:

public default 返回值类型 方法名(形参){方法体return 结果
}

使用方法:
1. 定义实现类\实现接口
2. 默认方法可以重写,也可以不重写
3. 创建实现类对象,调用默认方法

静态方法

定义格式:

public static 返回指类型 方法名(形参){方法体retuan 结果
}

使用方法:
1. 接口名直接调用

默认方法和静态方法的作用：

可以作为临时加的一个小功能来使用

public interface USB {//默认方法public default void methodDef(){System.out.println("我是默认方法");}
}
public class Mouse implements USB {//默认方法public default void methodDef(){System.out.println("我是默认方法");}//静态方法public static void methodSta(){System.out.println("我是接口中的静态方法");}//重写默认方法@Overridepublic void methodDef(){System.out.println("我是重写接口中的默认方法");}
}
public class Test01 {public static void main(String[] args) {Mouse mouse = new Mouse();mouse.methodDef();System.out.println("=============");USB.methodSta();静态方法可以直接调用接口名}
}

成员变量

定义格式：

 public static final 数据类型 变量名 = 值

使用方法：
1. 接口名直接调用
2. 可不写public static final ,默认会有

注意事项:

被static final修饰的成员变量需要手动赋值
习惯上我们将static final修饰的成员变量名称用大写

public interface USB {public static final int NUM1 = 100;int NUM2 = 200;//不写public static final 默认也有
}public class Test01 {public static void main(String[] args) {System.out.println(USB.NUM1);System.out.println(USB.NUM2);	//修饰的成员变量名称用大写}
}

接口的特点

接口可以多继承

public interface InterfaceA extends InterfaceB,InterfaceC{}

接口可以多实现

public class InterfaceImpl implements InterfaceA,InterfaceB{}

当一个类实现多个接口时,如果接口中的抽象方法有重名并且参数一样,只需要重写一次

public interface InterfaceA {public abstract void method();
}public interface InterfaceB {public abstract void method();
}public class InterfaceImpl implements InterfaceA,InterfaceB{@Overridepublic void method() {System.out.println("重写的method方法");}
}

当一个类实现多个接口时,如果多个接口中的默认方法有重名的且参数一样,必须重写一次默认方法

public interface InterfaceA {public abstract void method();public default void methodDef(){System.out.println("我是接口A中的默认方法");}
}public interface InterfaceB {public abstract void method();/*    public default void methodDef(){System.out.println("我是接口B中的默认方法");}*/public default void methodDef(int a) {System.out.println("我是接口B中的默认方法");}
}public class InterfaceImpl implements InterfaceA,InterfaceB{@Overridepublic void method() {System.out.println("重写的method方法");}/*    @Overridepublic void methodDef() {System.out.println("重写后的默认方法");}*/
}public class Test01 {public static void main(String[] args) {InterfaceImpl anInterface = new InterfaceImpl();anInterface.methodDef();anInterface.methodDef(10);}
}

一个子类可以继承一个父类的同时可以是实现一个或者多个接口
```
public class Zi extends Fu implements  InterfaceA,InterfaceB{}
```
注意事项:
1. 只要是父类中或者接口的抽象方法,子类或者实现类都要重写

接口和抽象类的区别

相同点:
1. 都位于继承体系,用于被其他类实现或者继承
2. 都不能new
3. 都包含抽象方法,其子类或者实现类都必须从重写这些抽象方法
不同点:
1. 抽象类:一般作为父类使用,可以有成员变量\构造\成员方法\抽象方法等
2. 接口:成员单一(一般抽取接口)抽取的都是方法,作为实现功能的大集合
3. 类不能多继承,但是接口可以