抽象类
抽象类:主要是对类本身进行抽象, 对于一个父类来说,如果其某个方法在父类之中实现出来没有任何意义, 必须根据子类情况来进行不同的实现。那么就可以将当前方法声明为抽象方法,必须根据子类情况来进行不同的实现。那么就可以将当前方法声明为抽象方法,抽象方法的类称为抽象类。
定义一个抽象类:
abstract class Animal{//抽象类 可以有抽象方法 也可以有非抽象方法
public abstract void bark();//抽象方法 没有方法体 不做具体实现
public void fun1(){//非抽象方法
System.out.println("Animal.fun1!!");
}
}
抽象类的使用:
抽象类的使用原则如下:
(1)抽象方法必须为public或者protected(因为如果为private,则不能被子类继承,子类便无法实现该方法),缺省情况下默认为public;
(2)抽象类不能直接实例化,需要依靠子类采用向上转型的方式处理;
(3)抽象类必须有子类,使用extends继承,一个子类只能继承一个抽象类;
(4)子类(如果不是抽象类)则必须覆写抽象类之中的全部抽象方法(如果子类没有实现父类的抽象方法,则必须将子类也定义为为abstract类。);
class Dog extends Animal{
public void bark() {
System.out.println("wangwang");
}
}
//如果一个抽象类 继承了一个抽象类 那么可以不实现基类的抽象方法
abstract class Cat extends Animal{
abstract void bark();
}
//如果一个类 再次继承了这个抽象类 必须进行实现
class LittleCat extends Cat{
public void bark() {
System.out.println("LittleCat miaomiao");
}
}
密封类
- 密封类和密封方法:类和方法被final修饰之后,类不能被继承,方法不能被修改(密封类不能用作基类)
- 密封类的作用:防止有意的派生
class Base{
public final void fun1(){
System.out.println("Base.fun1!!");
}
public void fun2(){
System.out.println("Base.fun2!!");
}
}
接口
接口:主要是对行为进行抽象
- 默认数据成员是public static final
- 默认成员方法是 public abstract
- 接口的实现,可以实现多个接口
- 接口和接口之间也可以继承
接口和抽象类的区别:
- 接口可以被实现多个,抽象类一次只能继承一个(继承–解决了java的单继承问题)
- 抽象类可以拥有非抽象方法,接口内都是抽象方法
- 接口的数据成员变量都是public static final,成员方法都是public static。抽象类的成员变量和成员方法都不能是private其余不作要求。
- 接口是对行为的抽象而抽象类是对类整体的抽象
//接口A
interface A {
int age = 10;
void fun1();
}
//接口B
interface B{
int b = 100;
void fun2();
}
//类C实现接口A和B(可以实现多个接口)
class C implements A,B{
public void fun1(){
System.out.println("A.fun1");
}
public void fun2() {
System.out.println("b.fun2");
}
}
接口和接口之间可以继承
//接口的继承
interface Mobike{
public void scan();
}
interface Ofo{
public void hand();
}
abstract class Bick{
public abstract void fun1();
}
class FlyingDove extends Bick implements Mobike,Ofo{
public void hand() {
System.out.println("Ofo.hand()");//.表示作用域
}
public void scan() {
System.out.println("Mobike.scan()");
}
public void fun1() {
System.out.println("Bike.fun1");
}
Cloneable
Cloneable接口主要是为了类的克隆。
class Money implements Cloneable{
double money = 10.0;
}
}
/*public interface Cloneable {
* }
*/
//Cloneable 空接口 标志接口
//作用:标志位 标记这个类可以进行clone 如果不实现 JVM无法识别
class Person implements Cloneable{
public String name;
Money m;
public Person(String name){
this.name = name;
m = new Money();
}
@Override
protected Object clone() throws CloneNotSupportedException {
//Person重写
Person p = (Person)super.clone();
p.m = (Money)this.m.clone();//对当前对象内的引用进行克隆
return p;
}
}
public class Test16 {
public static void main(String[] args) throws CloneNotSupportedException{
Person p1 = new Person("caocao");
Person p2 =(Person) p1.clone();
System.out.println(p1.m.money);
System.out.println(p2.m.money);
p1.m.money = 1000.0;
System.out.println(p1.m.money);
System.out.println(p2.m.money);
}
}
此时只克隆了person对象,并没有克隆Money对象。改变p1.m.money的值p2.m.money也会随之改变。
在Money类里重写clone方法:
class Money implements Cloneable{
double money = 10.0;
@Override
protected Object clone() throws CloneNotSupportedException {
// TODO Auto-generated method stub
return super.clone();
}
}
这样改变改变p1.m.money的值p2.m.money就不会改变。
Comparable(类内部比较器)
实现了Comparable接口的类可以和自己比较,依赖compareTo方法实现比较。compareTo方法的返回值是int,有三种情况:
1、比较者大于被比较者,那么返回正整数(compareTo里原本的)
2、比较者等于被比较者,那么返回0
3、比较者小于被比较者,那么返回负整数
class Person2 implements Comparable<Person2>{
private String name;
private int age;
private double score;
public Person2(String name, int age, double score) {
super();
this.name = name;
this.age = age;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
@Override
public String toString() {
return "Person2 [name=" + name + ", age=" + age + ", "
+ "score=" + score + "]";
}
public int compareTo(Person2 o){
return age - o.age;//按age排序
//return name.compareTo(o.name);//按name排序
//return (int)(score-o.score);//将score强转成int型排序
}
}
public static void main(String[] args) {
Person2[] array = new Person2[3];
array[0] = new Person2("caocao",18,29.0);
array[1] = new Person2("aiubei",98,19.0);
array[2] = new Person2("erke",38,99.99);
Arrays.sort(array);
System.out.println(Arrays.toString(array));
}
Comparator(类外部比较器)
Comparator接口里面有一个compare方法,方法有两个参数T o1和T o2,是泛型的表示方式,分别表示待比较的两个对象,方法返回值和Comparable接口一样是int,有三种情况:
1、o1大于o2,返回正整数
2、o1等于o2,返回0
3、o1小于o3,返回负整数