java中抽象类不能被封装_Java抽象类、接口和内部类

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{ }