目录
一、JAVA抽象类
1.定义
在打印图形的例子中,父类Shape中的draw方法并没有什么实际工作,绘制图形时都是由Shape类中的子类完成的,像这种没有实际工作的方法可以将它设计为一个抽象方法,包含抽象方法的类称为抽象类。
2.语法
使用abstract修饰的类被称为抽象类,抽象类中使用abstract修饰的方法被称为抽象方法。
abstract class shape{ //抽象类
float area;
public abstract void draw(); //抽象方法
public void getArea(){
System.out.println(area);
}
}
注意:①抽象方法不用给出具体的实现体;②抽象类也是类,内部可以包含普通方法和属性,甚至构造方法。
3.特性
(1)抽象类不能直接实例化对象;(2)抽象方法不能是private;(3)抽象方法不能被final和static修饰,因为抽象方法要被子类重写;(4)若子类在继承抽象类时没有重写方法,则子类应也定义为抽象类;(5)抽象类中不一定有抽象方法,但有抽象方法的类一定是抽象类;(6)子类在继承抽象类时也要考虑抽象类的构造方法。
二、JAVA接口
1.定义
接口可以看成是:多个类的公共规范,是一种引用数据类型。
2.语法
将class关键字换成interface关键字就定义了一个接口,接口中的方法都是抽象方法。
interface Ishape{
public static final int a=0; //成员变量
int b=0; //成员变量
public abstract void method1(); //成员方法
public void method2();
abstract void method3();
void method4();
}
注意:①接口当中只有抽象方法(无构造方法和代码块),但两个方法除外(被static、default修饰的方法);②接口当中的抽象方法默认都是public abstract修饰的,可省略;③接口当中的成员变量默认都是public static final 修饰的,不可改变,需赋初值;
3.特性
(1)接口不能进行实例化;(2)类和接口之间的关系可以使用implements进行关联;(3)接口也有对应的字节码文件;(4)接口解决了多继承问题。
4.实例
(1)USB接口
interface USB{ //定义USB接口
void opendevice();
void closedevice();
}
class KeyBoard implements USB{ //使用USB接口
@Override
public void opendevice() {
System.out.println("连接usb接口打开键盘");
}
@Override
public void closedevice() {
System.out.println("拔掉usb关掉键盘");
}
public void input(){
System.out.println("疯狂敲字");
}
}
class Mouse implements USB{ //使用USB接口
@Override
public void opendevice() {
System.out.println("连接usb接口打开鼠标");
}
@Override
public void closedevice() {
System.out.println("拔掉usb关掉鼠标");
}
public void click(){
System.out.println("疯狂敲击");
}
}
class Computer{
public void open(){
System.out.println("打开电脑");
}
public void close(){
System.out.println("关闭电脑");
}
public void use(USB usb){
usb.opendevice();
if(usb instanceof KeyBoard){
KeyBoard keyboard=(KeyBoard) usb;
keyboard.input();
}else if (usb instanceof Mouse) {
Mouse mouse = (Mouse) usb;
mouse.click();
} else {
System.out.println("转型失败");
}
usb.closedevice();
}
}
public class text {
public static void main(String[] args) {
Computer computer=new Computer();
KeyBoard keyboard=new KeyBoard();
Mouse mouse=new Mouse();
computer.open();
computer.use(keyboard);
System.out.println("=========================================");
computer.use(mouse);
computer.close();
}
}
结果:
(2)动物接口
abstract class Animal{
String name;
public Animal(String name){
this.name=name;
}
abstract void eat();
}
interface IRun{
void run();
}
interface IFly{
void fly();
}
interface ISwim{
void swim();
}
class Dog extends Animal implements IRun{
public Dog(String name){
super(name);
}
@Override
void eat() {
System.out.println(this.name+"吃狗粮!!!");
}
@Override
public void run() {
System.out.println(this.name+"正在跑!!!");
}
}
class Duck extends Animal implements IRun,IFly,ISwim{
public Duck(String name) {
super(name);
}
@Override
void eat() {
System.out.println(this.name+"吃鸭粮!!!");
}
@Override
public void run() {
System.out.println(this.name+"正在跑!!!");
}
@Override
public void fly() {
System.out.println(this.name+"正在飞!!!");
}
@Override
public void swim() {
System.out.println(this.name+"正在游泳!!!");
}
}
public class text {
public static void Eatting(Animal animal){
animal.eat();
}
public static void Running(IRun run){
run.run();
}
public static void Flying(IFly fly){
fly.fly();
}
public static void Swimming(ISwim swim){
swim.swim();
}
public static void main(String[] args) {
Dog dog = new Dog("小白");
Duck duck = new Duck("鸭鸭");
Eatting(dog);
Running(dog);
System.out.println("==========================================");
Eatting(duck);
Running(duck);
Flying(duck);
Swimming(duck);
}
}
结果:
5.接口解决了多继承问题
子类只能继承一个父类,但有些特性不是每一个子类都有的,但如果将特性分成几个类写的话子类只能继承一个,所以将特性分成接口类,子类可以联系多个接口类。
6.接口类和接口类的关系
接口类与接口类之间用extends关键字
interface IA{
void test1();
}
interface IB extends IA{
void test2();
}
class C implements IB{
@Override
public void test1() {
}
@Override
public void test2() {
}
}
注意:IB接口不仅仅具备了IB自己的功能,而且还具备了IA接口的功能
7.三种方法比较对象的某个属性大小
(1)默认方式比较属性大小
class Student implements Comparable <Student>{
String name;
int age;
public Student(String name,int age){
this.name=name;
this.age=age;
}
@Override
public int compareTo(Student o) { //重写接口中的方法
return this.age-o.age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class text {
public static void main(String[] args) {
Student[] students=new Student[3];
students[0]=new Student("笑笑",5);
students[1]=new Student("淘气",4);
students[2]=new Student("李华",12);
System.out.println("排序前:"+ Arrays.toString(students));
Arrays.sort(students); //默认方式年龄排序
System.out.println("排序后:"+ Arrays.toString(students));
}
}
结果:
(2)比较器比较属性大小
class Student {
public String name;
public int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
//两个比较器
class AgeComparator implements Comparator<Student>{
public int compare(Student o1,Student o2){
return o1.age-o2.age;
}
}
class NameComparator implements Comparator<Student>{
public int compare(Student o1,Student o2){
return o1.name.compareTo(o2.name);
}
}
public class text {
public static void main(String[] args) {
Student[] students=new Student[3];
students[0]=new Student("笑笑",5);
students[1]=new Student("淘气",4);
students[2]=new Student("李华",12);
System.out.println("排序前:"+ Arrays.toString(students));
AgeComparator agecomparator = new AgeComparator();
NameComparator namecomparator = new NameComparator();
Arrays.sort(students,agecomparator); //年龄排序
System.out.println("按年龄排序后:"+ Arrays.toString(students));
Arrays.sort(students,namecomparator); //姓名排序
System.out.println("按姓名排序后:"+ Arrays.toString(students));
}
}
结果:
(3)冒泡排序
class Student implements Comparable <Student>{
String name;
int age;
public Student(String name,int age){
this.name=name;
this.age=age;
}
@Override
public int compareTo(Student o) { //重写接口中的方法
return this.age-o.age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class text {
public static void MaoPao(Student[] students){
for(int i=0;i<students.length-1;i++){
for(int j=0;j<students.length-1-i;j++){
if((students[j].compareTo(students[j+1])>0)){ //默认方式比较排序
Student temp=students[j];
students[j]=students[j+1];
students[j+1]=temp;
}
}
}
}
public static void main(String[] args) {
Student[] students=new Student[3];
students[0]=new Student("笑笑",5);
students[1]=new Student("淘气",4);
students[2]=new Student("李华",12);
System.out.println("排序前:"+ Arrays.toString(students));
MaoPao(students);
System.out.println("排序后:"+ Arrays.toString(students));
}
}
结果: