✅作者简介:大家好,我是橘橙黄又青,一个想要与大家共同进步的男人😉😉
🍎个人主页:再无B~U~G-CSDN博客
目标:
1. 🍎抽象类
1.1 🍎抽象类概念
1.2 🍎抽象类语法
在Java中,一个类如果被 abstract 修饰称为抽象类,抽象类中被 abstract 修饰的方法称为抽象方法,抽象方法不用 给出具体的实现体。
// 抽象类:被abstract修饰的类
public abstract class Shape {
// 抽象方法:被abstract修饰的方法,没有方法体
abstract public void draw();
abstract void calcArea();
// 抽象类也是类,也可以增加普通方法和属性
public double getArea(){
return area;
}
protected double area; // 面积
}
1.3 🍎抽象类特性
1. 抽象类不能直接实例化对象
Shape shape = new Shape();
// 编译出错
Error:(30, 23) java: Shape是抽象的; 无法实例化
2. 抽象方法不能是 private 的
abstract class Shape {
abstract private void draw();
}
// 编译出错
Error:(4, 27) java: 非法的修饰符组合: abstract和private
3. 抽象方法不能被final和static修饰,因为抽象方法要被子类重写
public abstract class Shape {
abstract final void methodA();
abstract public static void methodB();
}
// 编译报错:
// Error:(20, 25) java: 非法的修饰符组合: abstract和final
// Error:(21, 33) java: 非法的修饰符组合
// 矩形类
public class Rect extends Shape {
private double length;
private double width;
Rect(double length, double width){
this.length = length;
this.width = width;
}
public void draw(){
System.out.println("矩形: length= "+length+" width= " + width);
}
public void calcArea(){
area = length * width;
}
}
//圆类
public class Circle extends Shape{
private double r;
final private static double PI = 3.14;
public Circle(double r){
this.r = r;
}
public void draw(){
System.out.println("圆:r = "+r);
}
public void calcArea(){
area = PI * r * r;
}
}
// 三角形类:
public abstract class Triangle extends Shape {
private double a;
private double b;
private double c;
@Override
public void draw() {
System.out.println("三角形:a = "+a + " b = "+b+" c = "+c);
}
// 三角形:直角三角形、等腰三角形等,还可以继续细化
//@Override
//double calcArea(); // 编译失败:要么实现该抽象方法,要么将三角形设计为抽象类
}
1.4 🍎抽象类的作用
有些同学可能会说了 , 普通的类也可以被继承呀 , 普通的方法也可以被重写呀 , 为啥非得用抽象类和抽象方法呢?
2. 🍎接口
在现实生活中,接口的例子比比皆是,比如:笔记本上的USB口,电源插座等。
2.2 🍎语法规则
接口的定义格式与定义类的格式基本相同,将class关键字换成 interface 关键字,就定义了一个接口。
public interface 接口名称{
// 抽象方法
public abstract void method1(); // public abstract 是固定搭配,可以不写
public void method2();
abstract void method3();
void method4();
// 注意:在接口中上述写法都是抽象方法,跟推荐方式4,代码更简洁
}
接口中的成员方法是默认被public abstract 是固定搭配,可以不写
注意:
1. 创建接口时, 接口的命名一般以大写字母 I 开头.2. 接口的命名一般使用 "形容词" 词性的单词.3. 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性.
2.3 🍎接口使用
接口不能直接使用,必须要有一个"实现类"来"实现"该接口,实现接口中的所有抽象方法。
public class 类名称 implements 接口名称 {// ...}
注意:子类和父类之间是extends 继承关系,类与接口之间是 implements 实现关系。
接口案例分析:
请实现笔记本电脑使用USB鼠标、USB键盘的例子
1. USB 接口:包含打开设备、关闭设备功能2. 笔记本类:包含开机功能、关机功能、使用 USB 设备功能3. 鼠标类:实现 USB 接口,并具备点击功能4. 键盘类:实现 USB 接口,并具备输入功能
代码:
// USB接口
public interface USB {
void openDevice();
void closeDevice();
}
// 鼠标类,实现USB接口
public class Mouse implements USB {
@Override
public void openDevice() {
System.out.println("打开鼠标");
}
@Override
public void closeDevice() {
System.out.println("关闭鼠标");
}
public void click(){
System.out.println("鼠标点击");
}
}
// 键盘类,实现USB接口
public class KeyBoard implements USB {
@Override
public void openDevice() {
System.out.println("打开键盘");
}
@Override
public void closeDevice() {
System.out.println("关闭键盘");
}
public void inPut(){
System.out.println("键盘输入");
}
}
// 笔记本类:使用USB设备
public class Computer {
public void powerOn(){
System.out.println("打开笔记本电脑");
}
public void powerOff(){
System.out.println("关闭笔记本电脑");
}
public void useDevice(USB usb){
usb.openDevice();
if(usb instanceof Mouse){
Mouse mouse = (Mouse)usb;
mouse.click();
}else if(usb instanceof KeyBoard){
KeyBoard keyBoard = (KeyBoard)usb;
keyBoard.inPut();
}
usb.closeDevice();
}
}
test类:
// 测试类:
public class TestUSB {
public static void main(String[] args) {Computer computer = new Computer();
computer.powerOn();
// 使用鼠标设备
computer.useDevice(new Mouse());
// 使用键盘设备
computer.useDevice(new KeyBoard());
computer.powerOff();
}
}
2.4 🍎接口特性
public class TestUSB {
public static void main(String[] args) {
USB usb = new USB();
}
}
// Error:(10, 19) java: day20210915.USB是抽象的; 无法实例化
public interface USB {
// Error:(4, 18) java: 此处不允许使用修饰符private
private void openDevice();
void closeDevice();
}
public interface USB {
void openDevice();
// 编译失败:因为接口中的方式默认为抽象方法
// Error:(5, 23) java: 接口抽象方法不能带有主体
void closeDevice(){
System.out.println("关闭USB设备");
}
}
public interface USB {
void openDevice(); // 默认是public的
void closeDevice(); // 默认是public的
}
public class Mouse implements USB {
@Override
void openDevice() {
System.out.println("打开鼠标");
}
// ...
}
// 编译报错,重写USB中openDevice方法时,不能使用默认修饰符
// 正在尝试分配更低的访问权限; 以前为public
5. 接口中可以含有变量,但是接口中的变量会被隐式的指定为 public static final(也就是常量) 变量
案例:
public interface USB {
double brand = 3.0; // 默认被:final public static修饰
void openDevice();
void closeDevice();
}
public class TestUSB {
public static void main(String[] args) {
System.out.println(USB.brand); // 可以直接通过接口名访问,说明是静态的
// 编译报错:Error:(12, 12) java: 无法为最终变量brand分配值
USB.brand = 2.0; // 说明brand具有final属性
}
}
public interface USB {
// 编译失败
public USB(){
}
{
} // 编译失败
void openDevice();
void closeDevice();
}
7. 接口虽然不是类,但是接口编译完成后字节码文件的后缀格式也是.class8. 如果类没有实现接口中的所有的抽象方法,则类必须设置为抽象类9. jdk8中:接口中还可以包含default方法。
2.5 🍎实现多个接口
class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
}
interface IFlying {
void fly();
}
interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
class Cat extends Animal implements IRunning {
public Cat(String name) {
super(name);
}
@Override
public void run() {
System.out.println(this.name + "正在用四条腿跑");
}
}
class Fish extends Animal implements ISwimming {
public Fish(String name) {
super(name);
}
@Override
public void swim() {
System.out.println(this.name + "正在用尾巴游泳");
}
}
class Duck extends Animal implements IRunning, ISwimming, IFlying {
public Duck(String name) {
super(name);
}
@Override
public void fly() {
System.out.println(this.name + "正在用翅膀飞");
}
@Override
public void run() {
System.out.println(this.name + "正在用两条腿跑");
}
@Override
public void swim() {
System.out.println(this.name + "正在漂在水上");
}
}
2.6 🍎接口间的继承
interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
}
class Frog implements IAmphibious {
...
}
2.7 🍎接口使用实例
在这之前我们先讲一个知识
compareTo接口的使用
主要作用是实现比较大小
默认的比较方式可以重写
案例:
public class TestStudent {
public static void main(String[] args) {
String str1 = "abc";
String str2 = "abc";
String str3 = "abc";
String str4 = "cbc";
System.out.println(str1.compareTo(str2));//和c语言的strcmp一样比较的是字符值
System.out.println(str3.compareTo(str4));//和c语言的strcmp一样比较的是字符值
}
}
输出结果:
compareTo比较对象里面的成员大小
//TestStudent类
public class TestStudent {
public static void main(String[] args) {
Student student1 = new Student(18,"zhanshang");
Student student2 = new Student(19, "lisi");
System.out.println(student1.compareTo(student2));
}
}
//Student类
public class Student implements Comparable<Student>{
int age;
String name;
public Student(int age, String name) {
this.age = age;
this.name = name;
}
// 名字比较大小
@Override
public int compareTo(Student o) {
if(this.name.compareTo(o.name) > 0){
return 1;
}else if(this.name.compareTo(o.name) == 0){
return 0;
}else{
return -1;
}
}
@Override
public String toString() {
return "Student{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
输出结果:
当然也可以使用年龄比较大小
局限性:
给对象数组排序
代码展示:
//TestStudent类
import java.util.Arrays;
public class TestStudent {
public static void main(String[] args) {
Student[] students = new Student[3];
students[0] = new Student(18,"zhanshang");
students[1] = new Student(19, "lisi");
students[2] = new Student(15, "wangwu");
//排序前
System.out.println(Arrays.toString(students));
//排序中
Arrays.sort(students);
//排序后
System.out.println(Arrays.toString(students));
}
//Student类
public class Student implements Comparable<Student>{
int age;
String name;
public Student(int age, String name) {
this.age = age;
this.name = name;
}
//名字比较大小
@Override
public int compareTo(Student o) {
if(this.name.compareTo(o.name) > 0){
return 1;
}else if(this.name.compareTo(o.name) == 0){
return 0;
}else{
return -1;
}
}
@Override
public String toString() {
return "Student{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
输出结果:
这个说明:Arrays.ToString();排序数组的时候,底层会调用compareTo的方法进行排序。
2.8🍎Clonable 接口和深拷贝
Clonable 接口
克隆本身的类要支持克隆,要用上接口Cloneable
浅拷贝
案例:
class Money {
public double m = 99.99;
}
class Person implements Cloneable{
int age;
public Money money = new Money();
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class TestDemo3 {
public static void main(String[] args) throws CloneNotSupportedException {
Person person1 = new Person();
Person person2 = (Person) person.clone();
System.out.println("通过person2修改前的结果");
System.out.println(person1.money.m);
System.out.println(person2.money.m);
person2.money.m = 13.6;
System.out.println("通过person2修改后的结果");
System.out.println(person1.money.m);
System.out.println(person2.money.m);
}
}
// 执行结果通过 person2 修改前的结果99.9999.99通过 person2 修改后的结果13.613.6
内部逻辑分析:
深拷贝:
代码:修改:
class Money implements Cloneable{
public double m = 99.99;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class Person implements Cloneable{
int age;
public Money money = new Money();
@Override
protected Object clone() throws CloneNotSupportedException {
Person temp = (Person) super.clone();
temp.money = (Money) this.money.clone();
return temp;
}
}
那么首先要Money要支持拷贝,对Money改:
对Person改:
2.9 🍎抽象类和接口的区别(重点)
- 抽象类是一种包含抽象方法的类,不能被实例化,只能被继承。
- 抽象类可以包含普通方法和抽象方法,子类必须实现所有抽象方法才能被实例化。
- 抽象类可以包含成员变量,构造方法,静态方法等。
- 子类只能继承一个抽象类。
- 抽象类可以用来定义子类的通用行为,提供默认实现。
接口:
- 接口是一种抽象类型,只包含常量和抽象方法的定义,不能包含普通方法的实现。
- 类可以实现多个接口,实现接口的类必须实现接口中定义的所有方法。
- 接口中的方法默认是公共的抽象方法,不需要使用abstract关键字。
- 接口主要用于定义类的契约,实现多态和解耦的目的。
- 接口可以被用来描述对象的行为,而不关心对象的具体实现。
3. 🍎Object类
3.1 🍎hashcode方法
回忆刚刚的toString方法的源码: 文章来源:https://www.toymoban.com/news/detail-850021.html
public String toString () {return getClass (). getName () + "@" + Integer . toHexString ( hashCode ());}
class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
public class TestDemo4 {
public static void main(String[] args) {
Person per1 = new Person("gaobo", 20) ;
Person per2 = new Person("gaobo", 20) ;
System.out.println(per1.hashCode());
System.out.println(per2.hashCode());
}
}
//执行结果
460141958
1163157884
class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
public class TestDemo4 {
public static void main(String[] args) {
Person per1 = new Person("gaobo", 20) ;
Person per2 = new Person("gaobo", 20) ;
System.out.println(per1.hashCode());
System.out.println(per2.hashCode());
}
}
//执行结果
460141958
460141958
1 、 hashcode 方法用来确定对象在内存中存储的位置是否相同2 、事实上 hashCode() 在散列表中才有用,在其它情况下没用。在散列表中 hashCode() 的作用是获取对象的 散列码,进而确定该对象在散列表中的位置。
好啦,今天的分享就到这里了 ,感谢观看。文章来源地址https://www.toymoban.com/news/detail-850021.html
到了这里,关于【JAVASE】抽象类和接口及其抽象类和接口的区别的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!