目录
*增强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