1.抽象方法、抽象类
1)抽象方法:
由abstract修饰
只有方法的定义,没有方法的具体实现(连{}都没有)
由abstract修饰的方法为抽象方法,抽象方法只有方法的定义,没有方法体实现,用一个分号结尾。即:方法五要素中,抽象方法缺少了一个要素(方法体),也可以将抽象方法理解为不完整的方法。
2)抽象类:
由abstract修饰
包含抽象方法的类必须是抽象类,不包含抽象方法的类也可以声明抽象类(意义不大)
抽象类不能被实例化
抽象类是需要被继承的
子类需要重写抽象类的所有抽象方法---常用
子类也可以声明为抽象类---不常用
抽象类的意义:
封装子类所共有的属性和行为---代码复用
为所有子类提供一种统一的类型---向上造型
可以包含抽象方法,为所有子类提供了统一的入口,子类的实现不同,但入口是一致的
由abstract修饰的类为抽象类,抽象类是不能实例化对象的,而一个类不能实例化是没有意义的,所以需要定义类来继承抽象类,它的子类必须重写所有的抽象方法,除非该类也声明为抽象类。
abstract class Foo{
private double c;
public Foo(double c){ //没什么意义,需要被子类重写
this.c = c;
}
public abstract double area(); //抽象方法,没有方法体,大括号也不存在
}
class Sub extends Foo{
public Sub(double c) { //需要重写构造方法
super(c);
}
public double area(){
return 0.0;
}
}
abstract class Sub2 extends Foo{ //抽象方法继承抽象方法
public Sub2(double c) { //需要重写构造方法,不需要重写抽象方法
super(c);
}
}
3)抽象类不可以被实例化
Foo f = new Foo(); //编译错误,抽象类不能被实例化
即使一个类中没有抽象方法,也可以将其定义为抽象类,同样,该类不可以实例化。
注意:abstract和final关键字不能同时修饰一个类,因为final使得类不可继承,而abstract修饰的类如果不可以继承将没有任何意义。
4)继承抽象类
一个类继承抽象类后,必须实现其抽象方法,不同的子类可以有不同的实现。
abstract class Foo{
private double c;
public Foo(double c){ //没什么意义,需要被子类重写
this.c = c;
}
public abstract String sayHi();
}
class Sub extends Foo{
public Sub(double c) { //需要重写构造方法
super(c);
}
public String sayHi(){
return "Hello";
}
}
4)抽象类的意义
为其子类提供一个公共的类型(父类引用指向子类对象,即向上造型)
封装子类中的重复内容(成员变量和方法)
定义有抽象方法,子类虽然有不同的实现,但该方法的定义是一致的(子类需要实现此抽象方法)
案例1:抽象类演示
public class AbstractDemo {
public static void main(String[] args){
//Shape s = new Shape(); //编译错误,抽象类不能被实例化
Shape[] shape = new Shape[4]; //创建Shape数组对象
shape[0] = new Circle(1); //向上造型
shape[1] = new Circle(2);
shape[2] = new Square(1);
shape[3] = new Square(2);
maxArea(shape); //调用求最大面积方法
}
private static void maxArea(Shape[] shape) {
double max = shape[0].area();
int maxIndex = 0; //最大面积下标
for(int i=0;i
double area = shape[i].area();
if(area>max){
max = area;
maxIndex=i;
}
}
System.out.println("最大面积为:"+max+"所在下标为:"+maxIndex);
}
}
abstract class Shape{ //抽象类---不完整的类
protected double c; //周长
public abstract double area(); //抽象方法---不完整
}
class Circle extends Shape{
public Circle(double c){
this.c = c;
}
public double area(){ //重写抽象方法---变不完整为完整
return 0.0796*c*c;
}
}
class Square extends Shape{
public Square(double c){
this.c = c;
}
public double area(){
return 0.0625*c*c;
}
}
2. 接口
是一个标准、规范,遵循了这个标准就能干某件事
是一种数据类型(引用类型)
由interface定义,只能包含常量和抽象方法,方法默认由public abstract修饰
接口不能被实例化
接口是需要被实现的,通过implements关键字实现,实现类:必须重写接口中的所有抽象方法
一个类可以实现多个接口,逗号分隔,若又继承又实现,必须先继承后实现
接口可以继承一个或多个接口,逗号分隔(extends)
1)定义接口
接口可以看成是特殊的抽象类。即:只包含抽象方法和常量的抽象类。通过interface关键字来定义接口。
interface Demo{
public static int x = 100;
public int y = 50;
double area(); //默认会加上public abstract修饰
public abstract void test();
}
2)实现接口
与继承不同,一个类可以实现多个接口,实现的接口直接用逗号分隔,该类需要实现这些接口中定义的所有方法。通过implements关键字实现接口。接口可以作为一种类型声明变量,一个接口类型的变量可以引用实现了该接口的类的对象,通过该变量可以调用该接口中定义的方法(具体的实现类提供了方法的实现)。一个接口类型变量,引用了子类的对象,调用时,调用的是子类对象的具体的实现。
public class Test {
public static void main(String[] args){
Demo d = new Aoo(); //一个接口类型变量,引用了子类的对象,调用时,调用的是子类对象的具体的实现
d.test(); //This is Aoo
}
}
interface Demo{
public static int x = 100;
public int y = 50;
double area(); //默认会加上public abstract修饰
public abstract void test();
}
class Aoo implements Demo{
public double area(){
return 0.0;
}
public void test(){
System.out.println("This is Aoo");
}
}
3)接口的继承
接口间可以存在继承关系,一个接口可以通过extends关键字继承另外一个接口,子接口继承了父接口中定义的所有方法。
interface Foo{
public void funFoo();
}
interface Goo{
public void funGoo();
}
interface Hoo extends Foo,Goo{ //接口可以继承一个或多个接口,逗号分隔
public void funHoo();
}
interface Ioo{
void funIoo();
}
class Joo implements Hoo,Ioo{ //一个类可以继承多个接口
public void funFoo(){} //重写父类的父类的抽象方法
public void funGoo(){} //重写父类的父类的抽象方法
public void funHoo(){} //重写父类的抽象方法
public void funIoo(){} //重写父类的抽象方法
}
4)接口和抽象类的区别
一个类只能继承一个抽象类,但可以实现多个接口
抽象类中可以包含抽象方法和非抽象方法,而接口中的所有方法均为抽象的
子类继承抽象类必须实现抽象类中所有抽象方法,否则子类也必须是抽象类。而子类实现接口则必须实现接口中所有的抽象方法。
案例2:接口的演示
public class InterfaceDemo {
public static void main(String[] args){
//Inter6 o1= new Inter6(); //编译错误,接口不能被实例化
Inter6 o2 = new Moo(); //向上造型
Inter5 o3 = new Moo();
}
}
//演示接口语法
interface Inter1{
public static final int NUM = 5;
public abstract void show();
double PI = 3.14; //默认public static final修饰
void say(); //默认public abstract修饰
//int count; //编译错误,常量必须声明同时初始化
//void test(){} //编译错误,抽象方法没有方法体
}
//演示接口实现
interface Inter2{
void show();
void say();
}
class Joo implements Inter2{
public void show(){}
public void say(){}
}
//演示接口的多实现、继承
interface Inter3{
void show();
}
interface Inter4{
void say();
}
abstract class Koo{
abstract void test();
}
class Loo extends Koo implements Inter3,Inter4{
public void show(){}
public void say(){}
void test(){}
}
//演示接口继承接口
interface Inter5{
void show();
}
interface Inter6 extends Inter5{
void say();
}
class Moo implements Inter6{
public void show(){}
public void say(){}
}
3. 多态
1)意义:
1.1)同一类型的引用指向不同的对象时,有不同的实现:行为的多态:cut()、run()
1.2)同一个对象被造型为不同的类型时,有不同的功能:对象的多态:水
2)向上造型:
2.1)父类型的引用指向子类的对象
2.2)能造型成为的类有:父类、所实现的接口
2.3)能点出来什么,看引用的类型
3)强制类型转换,成功的条件有两种:
3.1)引用所指向的对象,就是该子类型
3.2)引用所指向的对象,实现了该接口
4)若不满足以上两个条件,则发生ClassCastException类型转换异常
建议:在强转之前先通过instanceof判断引用指向的对象是否是该类型
4. 成员内部类:应用几率不大
1)类中套类,里面的成为Inner,外面的成为Outer
2)内部类通常只服务于外部类,对外不具备可见性
3)内部类对象通常是在外部类中创建的
4)内部类中可以直接访问外部类的成员,包括私有的
一般情况下,Inner对象会在Outer对象中创建(构造方法或其他方法),Inner对象中会有一个隐式的引用指向创建它的Outer类对象,外部类名.this.
5. 匿名内部类
1)若想创建一个类(子类)的对象,并且对象只被创建一次,此时该类不必命名,称之为匿名内部类
2)匿名内部类中访问外部的变量,该变量必须是final的
常见面试题:内部类有独立的.class吗? 答案:有
5. 面向对象三大特征
1)封装:
1.1)类:封装的是对象的属性和行为
1.2)方法:封装的是业务逻辑功能的实现
1.3)访问控制修饰符:封装的是访问的权限
2)继承:
2.1)作用:代码复用,通过extends来实现继承
2.2)父类/基类:共有的
子类/派生类:特有的
3.3)单一继承、多接口实现
3)多态:
3.1)意义:行为的多态、对象的多态
3.2)向上造型、强制类型转换(instanceof)
3.3)多态的表现形式:重写、重载
设计规则:
1)将所有子类共有的属性和行为,抽象到父类中
2)所有子类行为都一样,设计为普通方法
所有子类行为不一样,设计为抽象方法
3)将部分子类共有的行为,抽象到接口中
符合既是也是的原则,使用接口
接口是对继承的单根性的扩展——实现多继承
案例3:多态的演示
public class MultiTypeDemo {
public static void main(String[] args){
Aoo o1 = new Boo(); //向上造型(自动类型转换)
Boo o2 = (Boo)o1; //o1指向的对象就是Boo类型(强制类型转换)
Inter o3 = (Inter)o1; //o1指向的对象实现了Inter接口(强制类型转换)
//Coo o4 = (Coo)o1; //java.lang.ClassCastException:类型转换异常
if(o1 instanceof Coo){ //强转建议使用instanceof判断
Coo o5 = (Coo)o1;
}
}
}
interface Inter{}
class Aoo{}
class Boo extends Aoo implements Inter{}
class Coo extends Aoo{}
案例4:多态的演示2
public class UnionPayTest {
public static void main(String[] args) {
ABCATM atm = new ABCATM(); //atm机对象
UnionPay card = new ABCImpl(); //银联卡
atm.insertCard(card); //插卡
atm.payTelBill(); //支付电话费
}
}
class ABCATM{ //农行ATM机类
private UnionPay card; //银联卡
public void insertCard(UnionPay card){ //插卡
this.card = card;
}
public void payTelBill(){ //支付电话费按钮
if(card instanceof ABC){ //是农行卡
ABC abcCard = (ABC)card; //强转为农行卡
abcCard.payTelBill("12345679845", 500);
}else{ //不是农行卡
System.out.println("不是农行卡,不能支付电话费");
}
}
}
interface UnionPay{ //银联接口
public double getBalance(); //查询余额
public boolean drawMoney(double number); //取款
public boolean checkPwd(String input); //验证密码
}
interface ICBC extends UnionPay{ //工行接口
public void payOnline(double number); //在线支付
}
interface ABC extends UnionPay{ //农行接口
public boolean payTelBill(String phoneNum,double sum); //支付电话费
}
class ICBCImpl implements ICBC{ //工行卡
public double getBalance(){return 0.0;}
public boolean drawMoney(double number){return true;}
public boolean checkPwd(String input){return true;}
public void payOnline(double number){}
}
class ABCImpl implements ABC{ //农行卡
public double getBalance(){return 0.0;}
public boolean drawMoney(double number){return true;}
public boolean checkPwd(String input){return true;}
public boolean payTelBill(String phoneNum,double sum){
System.out.println("支付电话费成功");
return true;
}
}
案例5:成员内部类的演示
public class InnerClassDemo {
public static void main(String[] args){
Outer outer = new Outer(100);
outer.printTime();
//Inner g = new Inner(); //编译错误
}
}
class Outer{
private int time;
private Inner inner;
Outer(int time){
this.time = time;
inner = new Inner();
inner.timeInc();
}
public void printTime(){
System.out.println(Outer.this.time); //101
System.out.println(++time); //102
}
class Inner{
public void timeInc(){
time++;
}
}
}
在Outer构造方法中创建的Inner对象会有一个隐式的引用指向创建它的Outer对象,调用Inner对象的timeInc方法,即会对Outer的time属性进行操作。
案例6:匿名内部类的演示
public class NstInnerClassDemo {
public static void main(String[] args){
/*
* 1)创建了Inter2的一个子类,但是没有名字
* 2)为该子类创建了一个对象,叫o1
* 3)大括号中的为子类的类体
*/
Inter2 o1 = new Inter2(){};
/*
* 1)创建了Inter2的一个子类,但是没有名字
* 2)为该子类创建了一个对象,叫o2
* 3)大括号中的为子类的类体
*/
Inter2 o2 = new Inter2(){ };
int num = 5;
/*
* 1)创建了Inter1的一个子类,但是没有名字
* 2)为该子类创建了一个对象,叫o3
* 3)大括号中的为子类的类体
*/
Inter1 o3 = new Inter1(){
public void show(){
System.out.println("show");
System.out.println(num);
}
};
o3.show();
}
}
interface Inter1{
void show();
}
interface Inter2{ }