《Java从入门到精通》第九章学习笔记

第9章 类的高级特性

一、抽象类

抽象类只声明方法的存在，不能被实例化，就是说抽象类不能创建其对象，在定义抽象类时要在class前面加上abstract关键字。

/*定义一个抽象类Fruit，并定义其抽象方法
 *在其子类中实现该抽象方法
 */
abstract class Fruit {
    public String color;
    public Fruit(){
        color="green";
    }
    //定义一个抽象方法
    public abstract void harvest();
}

public class Farm {
    public static class Apple extends Fruit{
        @Override
        public void harvest(){
            System.out.println("收获苹果！");
        }
    }

    public static void main(String[] args){
        Apple apple=new Apple();
        System.out.println(apple.color);
        apple.harvest();
    }
}

二、内部类

在一个类中再定义一个类，即内部的成为内部类。内部类可以直接存取外部类的私有成员变量。

1、成员内部类：

public class OuterClass {
    innerClass in=new innerClass();//外部类中实例化内部类
    public void ouf(){      //外部类方法中通过内部类实例对象调用内部类方法
        in.inf();
    }
    class innerClass{     //定义内部类
        innerClass(){     //内部类构造方法
        }
        public void inf(){  //内部类成员方法
        }
        int y=20;        //定义内部类成员变量
    }
    public innerClass doit(){   //定义外部类方法，返回类型为内部类引用类型
        //y=4;            //外部类方法中不能直接访问内部类成员变量
        System.out.println("mark0:doit方法中的输出"+in.y);
        in.y=4;            //必须通过内部类实例对象访问
        return new innerClass();
    }
    public static void main(String[] args){
        OuterClass out=new OuterClass();
        OuterClass out1=new OuterClass();
        OuterClass.innerClass in=out.doit();
        //通过doit方法实例化内部类对象in
        //内部类的对象实例化操作必须在外部类或外部类的非静态方法中实现
        System.out.println("mark1:out.in方法中的输出"+out.in.y);
        System.out.println("mark2：直接in的输出--??这里输出为什么是20??"+in.y);//这里输出为什么是20??

        OuterClass.innerClass ina=out1.new innerClass();
        //或者通过外部类的实例对象调用内部类的构造方法
        System.out.println("mark3:out1.in方法中的输出"+out1.in.y);
        System.out.println("mark4：直接ina的输出"+ina.y);
    }
}

*如果外部类中和内部类中定义了同名称的成员变量，可以通过this关键字指定。

public class TheSameName {
    private int x;
    private class Inner{
        private int x=9;
        public void doit(int x){
            x++;        //调用方法的形参x
            this.x++;   //调用内部类的变量x
            TheSameName.this.x++;   //调用外部类的变量x
        }
    }
}

2、局部内部类
局部内部类即是在类的方法中定义的内部类。相应地，局部内部类的作用范围也是在这个方法体内。

public class SellOutClass {
    private String name;     //定义成员变量
    public SellOutClass(){   //定义构造函数
        name="苹果";
    }
    public void sell(int price){   //定义成员方法
        class Apple{               //定义局部内部类
            int innerPrice=0;       //局部内部类的成员变量
            public Apple(int price){ //局部内部类的构造方法
                innerPrice=price;
            }
            public void price(){     //局部内部类的成员方法
                System.out.println("现在开始销售"+name);
                System.out.println("单价为："+innerPrice+"元");
            }
        }
        Apple apple=new Apple(price);//实例化局部内部类
        apple.price();                 //调用局部内部类的方法
    }
    public static void main(String[] args){
        SellOutClass sample=new SellOutClass();//创建实例化对象
        sample.sell(100);  //通过该对象调用SellOutClass的方法
    }

}

3、匿名内部类

有时候内部类根据情况可以不取名，而直接通过创建的类的实例对象去实现，即在实例对象的体内编写代码。

因为匿名内部类没有名称，所以其使用默认的构造方法来生成内部类的对象。并且在匿名内部类定义结束后需要加分号。

public class OutString {

    public static void main(String[] args) {
        final String sourceStr="Ji Lin  Province !";
        IStringDeal s=new IStringDeal(){   //编写匿名内部类
            @Override                //重写接口的方法  
            public String filterBlankChar(){
                String convertStr=sourceStr;
                convertStr=convertStr.replaceAll(" ","");
                return convertStr;
            }
        };                    //注意这里要加分号
        System.out.println("源字符串："+sourceStr);
        System.out.println("转换后的字符串："+s.filterBlankChar());
    }
}

//定义接口
public interface IStringDeal {
    public String filterBlankChar();
}

4、静态内部类

静态内部类中可以定义静态成员（非静态内部类则不可以）；同时静态内部类不可以使用外部类的非静态成员。

5、内部类的继承

与普通类一样，内部类也可以被继承。在某个类继承内部类时，必须强制给这个类一个带参构造方法，并且该构造方法的参数

必须是内部类的外部类的引用。

class A{class B{}
}//创建A的内部类Bpublic class OutputInnerClass extends A.B{public OutputInnerClass(A a){a.super();}
}

 三、class类与Java反射

通过Java反射机制可以在程序中访问已经装载到JVM中的对象的描述，实现访问、检测和修改描述Java对象本身信息的功能。在java.lang.reflect包中提供了对该功能的支持。

所有Java类都继承了Object类，在Object类中定义了一个getClass()方法，该方法返回一个类型为Class的对象。代码如下：

Class textFieldC=JTextField.getClass();       //textField为JTextField类的对象

通过这个对象textFieldC，可以访问用来返回该对象的textField对象的描述信息，主要包括以下内容：

*包路径：getPackage();

*类名称：getName();

*继承类：getSuperclass();    //获得该类继承的类

*实现接口：getInterfaces();  //获得该类实现的所有接口

*构造方法：getConstructors();//获得所有权限为public的构造方法

*方法：getMethods();      //获得所有权限为public的方法

*成员变量：getFields()    //获得所有权限为public的成员变量

*内部类：getClasses()

四、实战练习

/*编写Java程序，创建一个类，并在其中创建成员内部类，通过该内部类计算 
 *从1到任意数的和的操作
 *在外部类中进行测试
 */
import java.util.Scanner;
public class Sum {
    InnerSum inner=new InnerSum();
    public class InnerSum{
        public int getSum(int n){
            if(n==1){
                return 1;
            }else {
                return getSum(n-1)+n;
            }
        }
    }
    public static void main(String[] args){
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入一个正整数：");
        int x=scan.nextInt();
        Sum sum=new Sum();
        int xSum=sum.inner.getSum(x);
        System.out.println("从1到"+x+"之和为"+xSum);
    }
}

//定义接口
public interface MyString {String makeString();
}
import java.util.Scanner;
public class Demo {//创建一个接口作为参数的成员方法public void showMyString(MyString a){String x=a.makeString();System.out.println("my string is:"+x);}public static void main(String[] args) {// TODO Auto-generated method stubDemo myDemo=new Demo();//实例化对象//调用成员方法//方法一：实参通过匿名内部类的方法创建myDemo.showMyString(new MyString(){    public String makeString(){System.out.println("plz input your string:");Scanner scan=new Scanner(System.in);return scan.nextLine();}});//方法二：先通过匿名内部类创建接口的实例MyString myStr1=new MyString(){public String makeString(){System.out.println("plz input your string:");Scanner scan=new Scanner(System.in);return scan.nextLine();}};//再把上述创建的接口实例作为参数传递
        myDemo.showMyString(myStr1);}
}