java基础之接口（抽象类与接口的区别）_练和运动员案例： 乒乓球运动员和篮球运动员； 乒乓球教练和篮球教练；

HTTP

• HTTP 报文结构是怎样的？

• HTTP有哪些请求方法？

• GET 和 POST 有什么区别？

• 如何理解 URI？

• 如何理解 HTTP 状态码？

• 简要概括一下 HTTP 的特点？HTTP 有哪些缺点？

• 对 Accept 系列字段了解多少？

• 对于定长和不定长的数据，HTTP 是怎么传输的？

• HTTP 如何处理大文件的传输？

• HTTP 中如何处理表单数据的提交？

• HTTP1.1 如何解决 HTTP 的队头阻塞问题？

• 对 Cookie 了解多少？

• 如何理解 HTTP 代理？

• 如何理解 HTTP 缓存及缓存代理？

• 为什么产生代理缓存？

• 源服务器的缓存控制

• 客户端的缓存控制

• 什么是跨域？浏览器如何拦截响应？如何解决？

  开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】

}

**2、接口成员特点**

成员变量；只能是常量，并且是静态的。
        默认修饰符：public static final
        建议：自己手动给出。
构造方法：接口没有构造方法。
成员方法：只能是抽象方法。
        默认修饰符：public abstract
        建议：自己手动给出。

所有的类都默认继承自一个类：Object。
类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。

interface Inter {
public int num = 10;
public final int num2 = 20;
public static final int num3 = 30;

//错误: 需要<标识符>
//public Inter() {}

//接口方法不能带有主体
//public void show() {}

//abstract void show(); //默认public
public void show(); //默认abstract

}

//接口名+Impl这种格式是接口的实现类格式
/*
class InterImpl implements Inter {
public InterImpl() {
super();
}
}
*/

class InterImpl extends Object implements Inter {
public InterImpl() {
super();
}

public void show() {}

}

//测试类
class InterfaceDemo2 {
public static void main(String[] args) {
//创建对象
Inter i = new InterImpl();
System.out.println(i.num);
System.out.println(i.num2);
//i.num = 100;
//i.num2 = 200;
//System.out.println(i.num); //无法为最终变量num分配值
//System.out.println(i.num2);//无法为最终变量num2分配值
System.out.println(Inter.num);
System.out.println(Inter.num2);
System.out.println(“--------------”);
}
}

**3、类与类,类与接口以及接口与接口的关系**

类与类：
继承关系,只能单继承,可以多层继承。
类与接口：
实现关系,可以单实现,也可以多实现。
并且还可以在继承一个类的同时实现多个接口。
接口与接口：
继承关系,可以单继承,也可以多继承。

interface Father {
public abstract void show();
}

interface Mother {
public abstract void show2();
}

interface Sister extends Father,Mother {

}

//class Son implements Father,Mother //多实现
class Son extends Object implements Father,Mother {
public void show() {
System.out.println(“show son”);
}

public void show2() {
    System.out.println("show2 son");
}

}

class InterfaceDemo3 {
public static void main(String[] args) {
//创建对象
Father f = new Son();
f.show();
//f.show2(); //报错

    Mother m = new Son();
    //m.show(); //报错
    m.show2();
}

}

**4、猫狗案例**

/*
加入跳高的额外功能

分析：从具体到抽象
猫：
姓名,年龄
吃饭，睡觉
狗：
姓名,年龄
吃饭，睡觉

由于有共性功能，所以，我们抽取出一个父类：
动物：
    姓名,年龄
    吃饭();
    睡觉(){}

猫：继承自动物
狗：继承自动物

跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口
接口：
    跳高

部分猫：实现跳高
部分狗：实现跳高

实现；
从抽象到具体

使用：
使用具体类
*/

//定义跳高接口
interface Jumpping {
//跳高功能
public abstract void jump();
}

//定义抽象类
abstract class Animal {
//姓名
private String name;
//年龄
private int age;

public Animal() {}

public Animal(String name,int age) {
    this.name = name;
    this.age = age;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
}

//吃饭();
public abstract void eat();

//睡觉(){}
public void sleep() {
    System.out.println("睡觉觉了");
}

}

//具体猫类
class Cat extends Animal {
public Cat(){}

public Cat(String name,int age) {
    super(name,age);
}

public void eat() {
    System.out.println("猫吃鱼");
}

}

//具体狗类
class Dog extends Animal {
public Dog(){}

public Dog(String name,int age) {
    super(name,age);
}

public void eat() {
    System.out.println("狗吃肉");
}

}

//有跳高功能的猫
class JumpCat extends Cat implements Jumpping {
public JumpCat() {}

public JumpCat(String name,int age) {
    super(name,age);
}

public void jump() {
    System.out.println("跳高猫");
}

}

//有跳高功能的狗
class JumpDog extends Dog implements Jumpping {
public JumpDog() {}

public JumpDog(String name,int age) {
    super(name,age);
}

public void jump() {
    System.out.println("跳高狗");
}

}

class InterfaceTest {
public static void main(String[] args) {
//定义跳高猫并测试
JumpCat jc = new JumpCat();
jc.setName(“哆啦A梦”);
jc.setAge(3);
System.out.println(jc.getName()+“—”+jc.getAge());
jc.eat();
jc.sleep();
jc.jump();
System.out.println(“-----------------”);

    JumpCat jc2 = new JumpCat("加菲猫",2);
    System.out.println(jc2.getName()+"---"+jc2.getAge());
    jc2.eat();
    jc2.sleep();
    jc2.jump();

    //定义跳高狗并进行测试的事情自己完成。
}

}

**5、老师和学生案例**

/*
加入抽烟的额外功能

分析：从具体到抽象
老师：姓名，年龄，吃饭，睡觉
学生：姓名，年龄，吃饭，睡觉

由于有共性功能，我们提取出一个父类，人类。

人类：
    姓名，年龄
    吃饭();
    睡觉(){}

抽烟的额外功能不是人或者老师，或者学生一开始就应该具备的，所以，我们把它定义为接口

抽烟接口。

部分老师抽烟：实现抽烟接口
部分学生抽烟：实现抽烟接口

实现：从抽象到具体

使用：具体

*/
//定义抽烟接口
interface Smoking {
//抽烟的抽象方法
public abstract void smoke();
}

//定义抽象人类
abstract class Person {
//姓名
private String name;
//年龄
private int age;

public Person() {}

public Person(String name,int age) {
    this.name = name;
    this.age = age;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
}

//吃饭();
public abstract void eat();

//睡觉(){}
public void sleep() {
    System.out.println("睡觉觉了");
}

}

//具体老师类
class Teacher extends Person {
public Teacher() {}

public Teacher(String name,int age) {
    super(name,age);
}

public void eat() {
    System.out.println("吃大白菜");
}

}

//具体学生类
class Student extends Person {
public Student() {}

public Student(String name,int age) {
    super(name,age);
}

public void eat() {
    System.out.println("吃红烧肉");
}

}

//抽烟的老师
class SmokingTeacher extends Teacher implements Smoking {
public SmokingTeacher() {}

public SmokingTeacher(String name,int age) {
    super(name,age);
}

public void smoke() {
    System.out.println("抽烟的老师");
}

}

//抽烟的学生
class SmokingStudent extends Student implements Smoking {
public SmokingStudent() {}

public SmokingStudent(String name,int age) {
    super(name,age);
}

public void smoke() {
    System.out.println("抽烟的学生");
}

}

class InterfaceTest2 {
public static void main(String[] args) {
//测试学生
SmokingStudent ss = new SmokingStudent();
ss.setName(“林青霞”);
ss.setAge(27);
System.out.println(ss.getName()+“—”+ss.getAge());
ss.eat();
ss.sleep();
ss.smoke();
System.out.println(“-------------------”);

    SmokingStudent ss2 = new SmokingStudent("刘意",30);
    System.out.println(ss2.getName()+"---"+ss2.getAge());
    ss2.eat();
    ss2.sleep();
    ss2.smoke();

    //测试老师留给自己练习
}

}

**6、抽象类和接口的区别：**

A:成员区别

更多面试题

**《350页前端校招面试题精编解析大全》**内容大纲主要包括 HTML，CSS，前端基础，前端核心，前端进阶，移动端开发，计算机基础，算法与数据结构，项目，职业发展等等

开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】

= new SmokingStudent(“刘意”,30);
System.out.println(ss2.getName()+“—”+ss2.getAge());
ss2.eat();
ss2.sleep();
ss2.smoke();

    //测试老师留给自己练习
}

}

**6、抽象类和接口的区别：**

A:成员区别

更多面试题

**《350页前端校招面试题精编解析大全》**内容大纲主要包括 HTML，CSS，前端基础，前端核心，前端进阶，移动端开发，计算机基础，算法与数据结构，项目，职业发展等等

开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】

[外链图片转存中…(img-nqQkeonz-1715825108888)]