java 基础知识十一 抽象类和 接口

java  基础知识十一   抽象类和 接口  

1、抽象类

抽象类和接口也是多态的体现方式

抽象类：类中没有足够信息描述具体的对象，这样的类称为抽象类

抽象类分两种展现方式 abstract class一种是接口 interface  

2、abstract class 一般描述为抽象类  interface 一般描述为接口

抽象类定义

注意：在抽象类中的方法不一定是抽象方法,但是含有抽象方法的类必须被定义成抽象类 



 

区别和对比：

　     1.abstract class在
4000
Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。

　     2.在abstract class中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是static final的，
    不 过在 interface中一般不定义数据成员），所有的成员方法都是abstract的。
3.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。 

　     4.实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。

　     5.接口中定义的变量默认是public static final型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。抽象类中的变量默认是 friendly型，其值可以在子类
    中 重新定义，也可以重新赋值。 
6.接口中的方法默认都是 public,abstract类型的。

3、内部类 
内部类就是定义在外部类中的类，类名不与文件名相同，可以是静态static的，也可以是其他修饰符
内部类一旦编译成功就和外部类成为不同的两个类，区别为outer.class和outer$inner.class两类

成员内部类：外部类的成员，必须先创建了外部类对象 才能创建成员内部类对象 不可以有static数据和属性
局部内部类：定义在方法和作用域内的类，在作用域的范围内有效
静态内部类：定义为static的内部类，可以有static数据和属性
匿名内部类：没有名字而且只能使用一次的内部类，必须继承一个父类或者实现一个接口

附件 

1、抽象类

package com.vivi.study.abstracttest;

abstract class AbstractHello {

private String type;
// 抽象方法 只声明 不实现 交给继承者实现
abstract void method1();
void method2(){
System.out.println("我是非抽象方法");
};
}

2、抽象类子类 包含内部类 在内部类测试代码中展现

package com.vivi.study.abstracttest;
/*
* 抽象类子类
* 实现父类方法
* 成员内部类
* 静态成员内部类
* 局部内部类
*/
public class AbstractHelloSub extends AbstractHello{

@Override
void method1() {
System.out.println("实现父类抽象方法 ");
}

public subClass getSubClass(){
return new subClass();
}

// 成员内部类
public class subClass{
// 不能含有static 变量和方法 会报错
// public static int age=1;

public int getSubName() {
return subName;
}
public void setSubName(int subName) {
this.subName = subName;
}
private int subName;
public void subMethod(){
System.out.println("");
}
}

// 局部内部类 定义在方法中的内部类
public void getClassMethod(int mage){
class SubClassInMethod{

public SubClassInMethod(int age){
this.setAge(age);
System.out.println("局部内部类演示"+age);
}

private int age;

public int getAge() {
return age+2;
}

public void setAge(int age) {
this.age = age;
}
}

SubClassInMethod mSubClassInMethod=new SubClassInMethod(3);
System.out.println("局部类方法调用"+mSubClassInMethod.getAge());
}

// 静态内部类 可以有静态变量和静态方法
public static class staticSubClass{
public static int age=1;
private String name;

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}

public static void getMName(String name1){
System.out.println("来自静态内部类的"+name1);
}
}
}

3、抽象类测试

package com.vivi.study.abstracttest;

public class TestAbsctract {

public static void main(String[] args) {
// 抽象类不能直接创建对象 否则编译不通过
// Cannot instantiate the type AbstractHello
// AbstractHello abstractHello1=new AbstractHello();

// 抽象类可以通过对象引用指向非抽象子类对象
// 类比下动态绑定就知道了 父类 父类引用 =new 子类(); 这也是多态的一种形式
AbstractHello abstractHello2=new AbstractHelloSub();
abstractHello2.method1();

// 但是抽象类 可以通过 隐式内部类重写其抽象方法来new对象
AbstractHello abstractHello3=new AbstractHello() {
@Override
void method1() {
System.out.println("抽象类创建对象 无法通过编译");
}
};
abstractHello3.method1();
}
}


4、接口类

package com.vivi.study.abstracttest;

public interface InterfaceHello {

/*
* 不能有成员方法
* 不能有静态代码块
* 对行为（方法）抽象
* 使用implement
*/
int type=1;//相当于 public static final int type=1;
void sayHello();// 相当于abstract void sayHello();
}


5、接口实现类

package com.vivi.study.abstracttest;

public class InterfaceHelloSub implements InterfaceHello{

@Override
public void sayHello() {
System.out.println("来自接口的public static final变量"+InterfaceHello.type);
}
}

6、接口 抽象类 内部类测试

package com.vivi.study.abstracttest;

public class InterfaceAndAbstractTest {

public static void main(String[] args) {

// 内部类测试
//1、匿名内部类

//内部类 接口方式==动态引用，将InterfaceHelloSub实例向上转型为InterfaceHello的引用
InterfaceHello interfaceHello0=new InterfaceHelloSub() ;
interfaceHello0.sayHello();
//匿名内部类 接口方式
InterfaceHello interfaceHello=new InterfaceHello() {

@Override
public void sayHello() {
System.out.println("匿名内部类 接口方式");
}
};
interfaceHello.sayHello();

//内部类 抽象类方式==动态引用，将AbstractHelloSub实例向上转型为AbstractHello的引用
AbstractHello abstractHello0=new AbstractHelloSub() ;
abstractHello0.method1();
//匿名内部类 抽象类形式 abstract 类
AbstractHello abstractHello=new AbstractHello() {

@Override
void method1() {
System.out.println("匿名内部类 抽象类形式 abstract 类");
}
};

abstractHello.method1();

// 2、成员内部类

// 成员内部类需要先创建了外部类，才能创建它自己的
// AbstractHelloSub.subClass sub=new AbstractHelloSub.subClass(); 这个会报错
AbstractHelloSub sub1=new AbstractHelloSub();
AbstractHelloSub.subClass sub2=sub1.getSubClass();
sub2.subMethod();

// 3、局部内部类 定义在方法中的内部类
sub1.getClassMethod(2);

// 4、静态内部类
AbstractHelloSub.staticSubClass.getMName("张三");
}
}