总结：接口和抽象类

发呆的百香果子

已于 2022-11-23 23:29:18 修改

阅读量64

点赞数

文章标签： java

于 2022-11-22 21:48:24 首次发布

本文链接：https://blog.csdn.net/m0_75100464/article/details/127929915

版权

*增强for循环的格式：

for(数据类型  变量名 : 数组或者集合对象){
		//循环体，变量即元素
}

public class test {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5};
        for(int num: arr){//等价于 int num=arr[i],i++
            if(num>=3){
                System.out.println(num);
            }
        }
    }
}

*抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类

*抽象类不能直接实例化对象

*抽象方法不能是 private 、final和static修饰的，因为抽象方法要被子类重写

接口：就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。

*接口的格式

public interface 接口名称{

}

*接口中的方法都是抽象方法，必须为public abstract void func()；成员变量必须为public static final 变量;

*"实现类"来"实现"该接口

public class 类名称 implements 接口名称{

}

*接口不能直接实例化对象

*重写接口中方法时，不能使用默认的访问权限，一定要加public

*接口中不能有静态代码块和构造方法（构造方法也是一个完整的方法体）

*每个接口中的抽象方法都要实现，否则类必须设置为抽象类

*Comparable 接口

*数组我们有一个现成的 sort 方法：Arrays.sort(数组名); 默认按照从小到大排序，但是不适用引用类型，（因为当有两个学生对象，电脑不知道该用名字比较还是年龄比较）这时需要Student 类实现Comparable 接口, 并实现其中的 compareTo 方法

class Student implements Comparable {//实现Comparable接口
    private String name;
    private int score;
public Student(String name, int score) {
    this.name = name;
    this.score = score;
    }//构造方法
@Override
 public String toString() {
 return "[" + this.name + ":" + this.score + "]";
    }//重写toString
@Override
 public int compareTo(Object o) {
    Student s = (Student)o;
    if (this.score > s.score) {//按照成绩排序
        return -1;
    } else if (this.score < s.score) {
        return 1;
    } else {
        return 0;
   }
  }//重写compareTo方法
}

*Clonable 接口

public class Student implements Cloneable{
    public String name;

    public Student(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }//重写克隆方法
}

public class test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student student1=new Student("杜宝宝");
        Student student2= (Student) student1.clone();
        System.out.println(student1);//杜宝宝
        System.out.println(student2);//杜宝宝
    }
}

*抽象类和接口的区别

主要区别：抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法.

其他区别：1.抽象类可以有任何各种权限，接口只能是public

2.使用extends继承抽象类，使用implements实现接口

3.一个抽象类可以实现多个接口，接口不能继承抽象类

4.一个子类只能继承一个抽象类，但可以实现多个接口

*hashcode方法用来确定对象在内存中存储的位置是否相同

*深拷贝和浅拷贝的区别

class Money {
    public double m = 99.99;
}
class Person implements Cloneable{
    Person person = new Person();
    Money money = new Money();
@Override
protected Object clone() throws CloneNotSupportedException {
    return super.clone();
// Person.money=(Money)this.money.clone();
   return person;-----深拷贝
 }
}
public class TestDemo3 {
public static void main(String[] args) throws CloneNotSupportedException {

    Person person2 = (Person) person.clone();
System.out.println(person2.money.m);
       
     person2.money.m = 13.6;
System.out.println(person2.money.m);
 }
}//结果还是99.99