文章目录
一、抽象类
1、抽象类概念
在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的
如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类
就像我们上一篇博客所写的打印图形一样
Java SE 继承和多态
这行代码什么也没有做,因此我们就可以把它设计成一个 抽象方法(abstractmethod), 包含抽象方法的类我们称为 抽象类(abstract class)
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; // 面积
}
抽象类也是类,内部可以包含普通方法和属性,甚至构造方法
3、抽象类特性
1.使用abstract 修饰的方法称为抽象方法
2.使用abstract 修饰的类称为抽象类
3.抽象类是不可以进行实例化的
4.在抽象类当中可以和普通类一样定义成员变量和成员方法
5.当一个普通的类继承了整个抽象类,那么需要重写这个抽象类里面的所有的抽象方法
6.抽象类的出现就是为了被继承
7.abstract 和 final 是天敌,它们不能共存
8.被 private 和 static 修饰的这个抽象类也是不可以共存的
abstract class Shape {
// public String name;
// public static int a;
//
// public void eat() {
//
// }
public abstract void draw();
}
class Cycle extends Shape {
@Override
public void draw() {
System.out.println("圆圈!");
}
}
class Rect extends Shape {
@Override
public void draw() {
System.out.println("矩形!");
}
}
public class Test {
public static void drawMap(Shape shape) {
shape.draw();
}
public static void main(String[] args) {
Shape shape = new Cycle();
Shape shape1 = new Rect();
drawMap(shape);
drawMap(shape1);
}
}
4、抽象类的作用
抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法
那么就有人会问, 普通的类也可以被继承呀, 普通的方法也可以被重写呀, 为啥非得用抽象类和抽象方法呢?
那是因为使用抽象类相当于多了一重编译器的校验.
使用抽象类的场景就如上面的代码, 实际工作不应该由父类完成, 而应由子类完成.
那么此时如果不小心误用成父类了, 使用普通类编译器是不会报错的.
但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题.
二、接口
1、接口的概念
在现实生活中,接口的例子比比皆是,比如:笔记本上的USB口,电源插座等
接口就是公共的行为规范标准,大家在实现时,只要符合规范标准,就可以通用
接口是一种引用数据类型
2、语法规则
接口的定义格式与定义类的格式基本相同,将class关键字换成 interface 关键字,就定义了一个接口
public interface 接口名称{
// 抽象方法
public abstract void method1(); // public abstract 是固定搭配,可以不写
public void method2();
abstract void method3();
void method4();
// 注意:在接口中上述写法都是抽象方法,跟推荐方式4,代码更简洁
}
注意事项:
- 创建接口时, 接口的命名一般以大写字母 I 开头.
- 接口的命名一般使用 “形容词” 词性的单词.
- 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性
3、接口使用
接口不能直接使用,必须有一个实现类来实现接口,从而实现接口中的所有抽象方法
这里我们用一个例子进行说明:
请实现笔记本电脑使用USB鼠标、USB键盘的例子
1. USB接口:包含打开设备、关闭设备功能
2. 笔记本类:包含开机功能、关机功能、使用USB设备功能
3. 鼠标类:实现USB接口,并具备点击功能
4. 键盘类:实现USB接口,并具备输入功能
//usb接口
public interface USB {
void openDevice();
void closeDevice();
}
//笔记本类
public class Computer {
public void powerOn() {
System.out.println("打开电脑");
}
public void powerOff() {
System.out.println("关闭电脑");
}
public void uesService(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();
}
}
// 鼠标类
public class Mouse implements USB {
@Override
public void openDevice() {
System.out.println("鼠标开始工作");
}
public void click() {
System.out.println("疯狂点击鼠标!!!!!!!!!! ");
}
@Override
public void closeDevice() {
System.out.println("鼠标结束工作");
}
}
//键盘类
public class KeyBoard implements USB{
@Override
public void openDevice() {
System.out.println("插上键盘");
}
public void input() {
System.out.println("疯狂敲打键盘!!!!!!!");
}
@Override
public void closeDevice() {
System.out.println("关闭键盘");
}
}
//测试类
public class Test {
public static void main(String[] args) {
Computer computer = new Computer();
computer.powerOn();
Mouse mouse = new Mouse();
KeyBoard keyBoard = new KeyBoard();
computer.uesService(mouse);
System.out.println("=================");
computer.uesService(keyBoard);
computer.powerOff();
}
}
4、接口的特征
1、接口是使用 interface 方法来修饰的
2、接口中不能有被实现的方法,意味着只能有抽象方法。但是两个方法除外:一个是被 static 修饰的方法,一个是被 default 修饰的方法
3、接口当中的抽象方法,默认都是 public abstract 修饰的
4、接口当中的成员变量,默认都是 public static final 修饰的
5、接口 不能进行实例化
6、类和接口之间的关系,可以使用 implements 进行
7、接口也是有对应的字节码文件的
8、接口中的方法是不能在接口中实现的,只能由实现接口的类实现
public interface ITest {
void testA();
public static void testStatic() {
System.out.println("testStatic()");
}
default public void defaultMethod() {
System.out.println("hhhhhhhhh");
}
}
class TestDemo implements ITest {
@Override
public void testA() {
System.out.println("重写testA()");
}
@Override
public void defaultMethod() {
System.out.println("ooooooooo");
}
}
public class Test {
public static void main(String[] args) {
ITest.testStatic();
ITest testDemo = new TestDemo();
testDemo.defaultMethod();
}
}
9、重写接口中的构造方法时,不能使用默认的访问权限
10、接口中不能有静态代码块和构造方法
11、如果类没有实现接口的所有的抽象方法,则类必须设置为抽象类
abstract class TestDemo2 implements ITest {
public abstract void testDemo2();
}
class TestDemo3 extends TestDemo2 {
@Override
public void testA() {
}
@Override
public void testDemo2() {
}
}
5、实现多个接口
在Java中,类和类之间是单继承的,一个类只能有一个父类,即Java中不支持多继承,但是一个类可以实现多个接口
为什么我们说java解决了多继承的关系?
我们无法再同一个类中写大量的方法,因为不是所有的类都包含这些功能
那为什么不可以把这多个方法放在不同的类当中呢?
因为java 不能同时继承多个类
所以我们就把他封装成了接口
abstract class Animal {
public String name;
public int age;
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public abstract void eat();
}
interface IFly {
void fly();
}
interface IRun {
void run();
}
interface ISwim {
void swim();
}
class Dog extends Animal implements IRun {
public Dog(String name,int age) {
super(name,age);
}
@Override
public void run() {
System.out.println(this.name + "正在跑!!!");
}
@Override
public void eat() {
System.out.println(this.name + "正在吃狗粮");
}
}
class Frog extends Animal implements IRun,ISwim {
public Frog(String name,int age) {
super(name,age);
}
@Override
public void run() {
System.out.println(this.name + "正在蛙跳!!!");
}
@Override
public void swim() {
System.out.println(this.name + "正在蛙泳!!!");
}
@Override
public void eat() {
System.out.println(this.name + "正在吃蛙粮");
}
}
class Duck extends Animal implements IRun,ISwim,IFly {
public Duck(String name, int age) {
super(name, age);
}
@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 + "正在用两只脚划着游泳");
}
@Override
public void eat() {
System.out.println(this.name + "正在吃鸭粮");
}
}
class Roboot implements IRun {
@Override
public void run() {
System.out.println("机器人在用两只脚跑!!");
}
}
public class Test {
public static void func1(Animal animal) {
animal.eat();
}
public static void running(IRun iRun) {
iRun.run();
}
public static void flying(IFly iFly) {
iFly.fly();
}
public static void swimming(ISwim iSwim) {
iSwim.swim();
}
public static void main(String[] args) {
running(new Duck("唐老鸭",3));
running(new Dog("二狗子",2));
running(new Frog("呱呱",1));
running(new Roboot());
System.out.println("=========================");
flying(new Duck("唐老鸭",3));
System.out.println("=========================");
swimming(new Duck("唐老鸭",3));
swimming(new Frog("呱呱",1));
}
public static void main1(String[] args) {
func1(new Duck("唐老鸭",3));
func1(new Dog("二狗子",2));
func1(new Frog("呱呱",1));
}
}
上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口
继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性
6、接口间的继承
在Java中,类和类之间是单继承的,一个类可以实现多个接口,接口与接口之间可以多继承。即:用接口可以达到多继承的目的。
接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字
2个关系:
1、类和接口之间的关系 —> implements 实现
2、接口和接口之间的关系 —> extends 拓展
interface A {
void testA();
}
interface B extends A {//B接口 不仅仅具备了B自己的功能 而且还具备了A这个接口的功能
void testB();
}
class TestDemo1 implements B {
@Override
public void testA() {
}
@Override
public void testB() {
}
}
public class Test {
}
接口间的继承相当于把多个接口合并在一起
7、接口使用实例
1.学生信息的比较
import java.util.Comparator;
class Student implements Comparable<Student>{//表示当前的类是可以比较的
public String name;
public int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//这种对类的侵入性比较强 一旦写好了规定的比较方式 那么以后只能以这种方式进行比较了
@Override
public int compareTo(Student o) {
if((this.age > o.age)) {
return 1;
}else if(this.age == o.age){
return 0;
}else {
return -1;
}
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
//这种方式做到了灵活比较 我们只需要传入 2个要比较的对象就可以了
//比较器
class AgeComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return o1.age - o2.age;
}
}
class NameComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
//String 自己重写的compareTo 方法
return o1.name.compareTo(o2.name);
}
}
public class Test {
public static void main(String[] args) {
Student student1 = new Student("zhangsan",10);
Student student2 = new Student("lisi",14);
AgeComparator ageComparator = new AgeComparator();
System.out.println(ageComparator.compare(student1,student2));;
//System.out.println(student1.compareTo(student2));
NameComparator nameComparator = new NameComparator();
System.out.println(nameComparator.compare(student1, student2));
}
public static void main1(String[] args) {
int a = 10;
int b = 20;
System.out.println(a > b);
}
}
一般情况下 自定义的类型 一定是可以进行比较的
这是一个人基本的功能
2. 给对象数组排序
class Student implements Comparable<Student>{//表示当前的类是可以比较的
public String name;
public int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//这种对类的侵入性比较强 一旦写好了规定的比较方式 那么以后只能以这种方式进行比较了
@Override
public int compareTo(Student o) {
// System.out.println("==========================");
return o.age - this.age;
/*if((this.age > o.age)) {
return 1;
}else if(this.age == o.age){
return 0;
}else {
return -1;
}*/
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
//这种方式做到了灵活比较 我们只需要传入 2个要比较的对象就可以了
//比较器
class AgeComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return o1.age - o2.age;
}
}
class NameComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
//String 自己重写的compareTo 方法
return o1.name.compareTo(o2.name);
}
}
public class Test {
public static void bubbleSort(Comparable[] comparables) {
for (int i = 0; i < comparables.length-1; i++) {
for (int j = 0; j < comparables.length-1; j++) {
if(comparables[j].compareTo(comparables[j+1]) > 0) {
Comparable tmp = comparables[j];
comparables[j] = comparables[j+1];
comparables[j+1] = tmp;
}
}
}
}
public static void main(String[] args) {
/*int[] array = {6,2,7,3,4};
Arrays.sort(array);
System.out.println(Arrays.toString(array));*/
Student[] students = new Student[3];
students[0] = new Student("zhangsan",10);
students[1] = new Student("lisi",4);
students[2] = new Student("abc",5);
System.out.println("排序前:" + Arrays.toString(students));
/*AgeComparator ageComparator = new AgeComparator();
NameComparator nameComparator = new NameComparator();
Arrays.sort(students,nameComparator);*/
bubbleSort(students);
System.out.println("排序后:" + Arrays.toString(students));
}
}
在这里我们使用了自己所写的sort 方法来完成刚才的排序过程(使用冒泡排序)
8、Clonable 接口和深拷贝
ava 中内置了一些很有用的接口, Clonable 就是其中之一
Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 “拷贝”.
但是要想合法调用 clone 方法, 必须要先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException 异常.
class Money {
public double m = 19.9;
}
class Person implements Cloneable{
public String name;
public int age;
public Money money = new Money();
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class Test {
public static void main(String[] args) throws CloneNotSupportedException{
Person person = new Person("张三",10);
Person person2 = (Person)person.clone();//clone
System.out.println("person:" + person.money.m);
System.out.println("person2:" + person2.money.m);
System.out.println("===================");
person.money.m = 99.99;
System.out.println("person:" + person.money.m);
System.out.println("person2:" + person2.money.m);
}
}
经过画图对内存划分进行展示
如上段代码,这里是浅拷贝
那么就会有人问,有没有深拷贝
当然存在!
class Money implements Cloneable{
public double m = 19.9;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class Person implements Cloneable{
public String name;
public int age;
public Money money = new Money();
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
//这里面在克隆person 但是没有克隆money 那么怎么克隆呢
Person tmp = (Person)super.clone();
tmp.money = (Money)this.money.clone();
return tmp;
//return super.clone();
}
}
public class Test {
public static void main(String[] args) throws CloneNotSupportedException{
Person person = new Person("张三",10);
Person person2 = (Person)person.clone();//clone
System.out.println("person:" + person.money.m);
System.out.println("person2:" + person2.money.m);
System.out.println("===================");
person.money.m = 99.99;
System.out.println("person:" + person.money.m);
System.out.println("person2:" + person2.money.m);
}
}
因为深拷贝中会拷贝出独立的空间,后面在经过改变之后person2 的值并没有进行改变
9、抽象类和接口的区别
抽象类和接口都是 Java 中多态的常见使用方式
核心区别:
抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写)
而接口中不能包含普通方法, 子类必须重写所有的抽象方法
三、Object 类
1、Object 类
Object是Java默认提供的一个类。
Java里面除了Object类,所有的类都是存在继承关系的。
默认会继承Object父类。即所有类的对象都可以使用Object的引用进行接收
class Person{}
class Student{}
public class Test {
public static void main(String[] args) {
function(new Person());
function(new Student());
}
public static void function(Object obj) {
System.out.println(obj);
}
}
执行结果:
Person@1b6d3586
Student@4554617c
所以在开发之中,Object类是参数的最高统一类型
2、获取对象信息
如果要打印对象中的内容,可以直接重写Object类中的toString()方法
// Object类中的toString()方法实现:
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
3、对象比较equals方法
在Java中,进行比较时:
a.如果左右两侧是基本类型变量,比较的是变量中值是否相同
b.如果==左右两侧是引用类型变量,比较的是引用变量地址是否相同
c.如果要比较对象中内容,必须重写Object中的equals方法,因为equals方法默认也是按照地址比较的
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
public class Test {
public static void main(String[] args) {
Person person = new Person("张三",10);
Person person1 = new Person("张三",10);
System.out.println(person.equals(person1));//equals 可以用来比较两个对象是否一样
}
}
比较对象中内容是否相同的时候,一定要重写equals方法
4、hashcode方法
hashCode()这个方法,他帮我算了一个具体的对象位置
hashcode方法源码:
public native int hashCode();
该方法是一个native方法,底层是由C/C++代码写的
@Override
public int hashCode() {
return Objects.hash(name, age);
}
public static void main(String[] args) {
Person person = new Person("张三",10);
Person person1 = new Person("张三",10);
System.out.println(person.hashCode());
System.out.println(person1.hashCode());
}
结论:
1、hashcode方法用来确定对象在内存中存储的位置是否相同
2、事实上hashCode() 在散列表中才有用,在其它情况下没用。在散列表中hashCode() 的作用是获取对象的
散列码,进而确定该对象在散列表中的位置