做网站链接怎么做,成都专业网站建设,设计工作室官网,网站快速排名案例目录 抽象类
接口
基本概念 多接口使用
为什么接口解决了Java的多继承问题#xff1f;
接口的继承
克隆
Clonable接口
拷贝
Object类 抽象类 1.使用abstract修饰的方法称为抽象方法
2.使用abstract修饰的类称为抽象类
3.抽象类不可以被实例化 e.g.Shape shape ne…目录 抽象类
接口
基本概念 多接口使用
为什么接口解决了Java的多继承问题
接口的继承
克隆
Clonable接口
拷贝
Object类 抽象类 1.使用abstract修饰的方法称为抽象方法
2.使用abstract修饰的类称为抽象类
3.抽象类不可以被实例化 e.g.Shape shape new Shape()//err
4.抽象类当中可以和普通类一样定义成员变量和方法
5.继承抽象类当一个普通的类继承了抽象类需要重写这个抽象类中所有的抽象方法
所以抽象类不能和final共存因为final这个关键字就是不让类重写的 6.抽象类的出现为了被继承如果有些工作应由子类完成而非父类那么父类是抽象类的话可以在实例化的时候报错因为抽象类本身不能被实例化要想使用只能创建该抽象类的子类然后重写抽象方法这样可以让我们更容易发现问题。作用
7.不可以用privatestatic修饰抽象类方法 一开始没有重写方法后面也需要重写方法
abstract class A extends Shape {public abstract void testA();
}class B extends A {Overridepublic void draw() {}Overridepublic void testA() {}
} 接口 接口就是公共的行为规范标准 基本概念
1.接口是使用interface修饰的
2.接口当中不能有被实现的方法只能有抽象方法但是被static和default方法修饰的方法除外 3.接口当中的抽象方法默认都是public abstract修饰的
4.接口当中的成员变量默认都是public static final修饰的 5.接口不能进行实例化 6.类和接口之间的关系可以使用implements来进行关联 7.系统给出两种选择要么抽象要么重写
重写接口方法的时候不能使用默认的访问权限 因为子类的访问权限要大于等于父类的父类默认是public abstract子类有可能是private就error了子类必须是public
8.接口虽然不是类但也是有对应的字节码文件.class的 private static void drawMap(Shape shape){shape.draw();}public static void main(String[] args) {//Shape shape new Shape();//无法实例化抽象的抽象类Shape shape1 new Rect();Shape shape2 new Flower();drawMap(shape1);drawMap(shape2);System.out.println();Shape[] shapes {new Rect(), new Rect(), new Flower(), new Flower()};//多态接口也可以发生向上转型和动态绑定for(Shape shape: shapes){shape.draw();}}9.接口中不能有代码块和构造方法 例子
//接口USB
package demo1;public interface USB {void openDevice();void closeDevice();
}
//类KeyBoard
public class KeyBoard implements USB{Overridepublic void openDevice() {System.out.println(插上键盘);}Overridepublic void closeDevice() {System.out.println(关上键盘);}public void input(){System.out.println(疯狂敲打键盘.......);}
}
//类Mouse
public class Mouse implements USB{Overridepublic void openDevice() {System.out.println(鼠标开始工作);}public void click(){System.out.println(疯狂点击鼠标......);}Overridepublic void closeDevice() {System.out.println(鼠标停止工作);}}多接口使用
为什么接口解决了Java的多继承问题
//抽象类Animal
abstract class Animal{public String name;public int age;public Animal(String name, int age){this.namename;this.ageage;}
// public void fly(){}
// public void run(){}
// public void swim(){}public abstract void eat();
}
在动物里面有的会飞有的会游有的会跑 但我们不能在Animal类里面定义这三个方法因为不是每个动物都会飞或游或跑
因为Java不能同时继承多个类所以这三个方法还不能直接写成不同的类
一个类可以实现多个接口所以我们把他封装成接口如下
//三个房卡其实可以看作个行为标准
//三个接口
interface IFly{void fly();
}
interface IRun{void run();
}
interface ISwim{void swim();
}
想办法让三种动物执行多继承
//狗是一个动物具备跑的功能
//鼠标放extends ALTENTER可以快速构造方法
//鼠标放Animal抽象类 ALTENTER可以快速重写方法
class Dog extends Animal implements IRun{Dog(String name, int age){super(name,age);}Overridepublic void run() {System.out.println(this.name 在用四条腿跑步);}Overridepublic void eat() {System.out.println(this.name 正在吃);}
}
//蛙会跑会游
class Frog extends Animal implements IRun,ISwim{public Frog(String name, int age){super(name, age);}Overridepublic void run() {System.out.println(this.name 正在用两条腿跑);}Overridepublic void swim() {System.out.println(this.name 正在蛙泳);}Overridepublic void eat() {System.out.println(this.name 正在吃蛙粮);}
}
//鸭会跑会游会飞
class Duck extends Animal implements IRun, ISwim, IFly{public Duck(String name, int age) {super(name, age);}Overridepublic void fly() {System.out.println(this.name 正在用翅膀飞);}Overridepublic void run() {System.out.println(this.name 正在撅着屁股跑);}Overridepublic void swim() {System.out.println(this.name 正在用两只脚划水);}Overridepublic void eat() {System.out.println(this.name 正在吃鸭粮);}
}
public class Test {public static void func1(Animal animal){animal.eat();}public static void main1(String[] args) {//多态func1(new Duck(唐老鸭,10));func1(new Dog(二狗子,10));func1(new Frog(青蛙,10));}
class Robot implements IRun{Overridepublic 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(唐老鸭,10));running(new Dog(二狗子,10));running(new Frog(青蛙,10));running(new Robot());//不管是不是动物System.out.println();flying(new Duck(唐老鸭,10));System.out.println();swimming(new Duck(唐老鸭,10));swimming(new Frog(青蛙,10));} 接口的继承
interface A{void testA();
}
interface B extends A{void testB();
}
B接口不仅仅具备了B自己的功能还具备了A接口的功能 用一个test来测试发现既得重写A的方法还得重写B的方法
关系
1.类和接口implements 实现
2.接口和接口extends 拓展
接口使用实例
正常数字比较大小 public static void main1(String[] args) {int a 10;int b 20;System.out.println(ab);//输出false}
但是到了类的引用就比较不了了因为地址无法比较
class Student{public String name;public int age;public Student(String name, int age) {this.name name;this.age age;}Overridepublic String toString() {return Student{ name name \ , age age };}
} 我们要解决这两个学生要根据什么比较年龄姓名
我们需要实现一个接口
Java里面有一个Comparable接口表示当前的类是可以比较的 重写compareTo方法 Overridepublic int compareTo(Student o) {if (this.age o.age){return 1;} else if (this.age o.age) {return 0;}else{return -1;}}
调用 分析 返回结果 现在我想根据姓名比较但如果要改变compareTo的逻辑得先复制后注释掉原来的方法再进行修改后单个比较这样巨麻烦这也叫做对类的侵入性比较强一旦写好了规定的比较方式那么以后只能以这种方式进行比较这不是我们想要的那有没有另一种方法可以及能按照年龄比较又能按照姓名比较呢
我们可以设计一个年龄比较器 comparator里面有一个方法 重写这个方法
class AgeComparator implements ComparatorStudent{Overridepublic int compare(Student o1, Student o2) {return o1.age-o2.age;}
}
调用 姓名也是同理
class NameComparator implements ComparatorStudent{Overridepublic int compare(Student o1, Student o2) {return o1.name.compareTo(o2.name);}
}
这里的compareTo我们点进去看是这样的 因为String类实现了Compare接口用ASCII码来计算所以我们调用的是String自己重写的compareTo方法 调用方法 这种方法好处就是比较灵活只需要传入两个要比较的对象 数组的排序方法 /* int[] array {1,2,31,14};Arrays.sort(array);System.out.println(Arrays.toString(array));*/
定义五个学生并组成数组
Student[] students new Student[] {
new Student(张三, 95),
new Student(李四, 96),
new Student(王五, 97),
new Student(赵六, 92),
};
我们是否可以沿用数组的排序思想给学生排序呢
Arrays.sort(students);
System.out.println(Arrays.toString(students));
// 运行出错, 抛出异常.
Exception in thread main java.lang.ClassCastException: Student cannot be cast to java.lang.Comparable 对于 sort 方法来说 , 需要传入的数组的每个对象都是 可比较 的 , 需要具备 compareTo 这样的能力 . 通过重写 compareTo 方法的方式 , 就可以定义比较规则 . //修改comparable的sort方法底层public static void bubbleSort(Comparable[] comparables) {for (int i 0; i comparables.length-1; i) {for (int j 0; j comparables.length-1-i; j) {if(comparables[j].compareTo(comparables[j1]) 0) {Comparable tmp comparables[j];comparables[j] comparables[j1];comparables[j1] tmp;}}}}public static void main(String[] args) {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));//bubbleSort(students);Arrays.sort(students);System.out.println(排序后 Arrays.toString(students));} 克隆
Clonable接口 Person person new Person(张三,10);Person person1 person;//clone 现在想用第一个person克隆一个新的person1出来Java的Obeject类里面有一个克隆方法 因为是protected修饰的我们没办法直接在person后面.clone调用方法所以需要super.clone() //可能会抛出异常这个异常叫做不知处克隆异常是编译时期的异常Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();} 所以我们改一下main函数 还报错克隆方法的返回值是Objectperson1的类是Person父类Object给子类Person是不允许的所以我们需要强转 Person person1 (Person) person.clone();//clone
当我们来打印这两个person的时候程序爆出问题 这说明我们自己写的类型要支持克隆的时候要给它实现一个克隆接口Cloneable 但是点进去这个接口我们发现居然是空的结果也没错那实现这个接口意义在哪 这种接口叫做空接口或者标记接口作用是表明当前类是可以被克隆的 拷贝 打印结果是什么呢 分析 目前这种情况叫做浅拷贝只有一个对象的时候就像两个人抢一个遥控器遥控器变了19.9-99.99两个人抢的遥控器也跟着改变
深拷贝把对象里面引用等信息拷贝出来一份
接下来我们要来实现深拷贝 Person类里面的super.clone()还在克隆person还没有克隆money我们可以借助一个中间变量来帮助克隆
Person tmp (Person) super.clone(); 再把Money类复制一份
tmp.money (Money)this.money.clone();
这里的this就是person money的地址改成0x999假设再把这个0x999给到tmp person1用来接收tmp的值 整个的深拷贝分析流程 深拷贝完成打印结果如下 深拷贝相当于把一个遥控器复制一份分给另一个人一个人拿到新的遥控器99.99另一个人还拿着老的遥控器19.9 Object类 红色代表private修饰绿色代表public修饰一把代表protected修饰
equals方法 public static void main(String[] args) {Person person new Person(张三,10);Person person1 new Person(张三,10);//System.out.println(person person1);System.out.println(person.equals(person1));//直接调用跟上一句没区别}
两个学生名字年龄都一样但是因为地址不一样所以比较结果falseequals默认比较对象的地址这背离我们的初衷这两个学生得相等
我们就在Person类里面重写这个方法 //重写equals方法Overridepublic boolean equals(Object obj) {Person tm (Person) obj;return this.name.equals(tm.name) this.age tm.age;}
也可以再generate里面重写 Overridepublic 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);}Overridepublic int hashCode() {return Objects.hash(name, age);}
hashcode方法可以看我以后的博客
