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

 1 /*定义一个抽象类Fruit，并定义其抽象方法
 2  *在其子类中实现该抽象方法
 3  */
 4 abstract class Fruit {
 5     public String color;
 6     public Fruit(){
 7         color="green";
 8     }
 9     //定义一个抽象方法
10     public abstract void harvest();
11 }
12 
13 public class Farm {
14     public static class Apple extends Fruit{
15         @Override
16         public void harvest(){
17             System.out.println("收获苹果！");
18         }
19     }
20 
21     public static void main(String[] args){
22         Apple apple=new Apple();
23         System.out.println(apple.color);
24         apple.harvest();
25     }
26 }

 1 public class OuterClass {
 2     innerClass in=new innerClass();//外部类中实例化内部类
 3     public void ouf(){      //外部类方法中通过内部类实例对象调用内部类方法
 4         in.inf();
 5     }
 6     class innerClass{     //定义内部类
 7         innerClass(){     //内部类构造方法
 8         }
 9         public void inf(){  //内部类成员方法
10         }
11         int y=20;        //定义内部类成员变量
12     }
13     public innerClass doit(){   //定义外部类方法，返回类型为内部类引用类型
14         //y=4;            //外部类方法中不能直接访问内部类成员变量
15         System.out.println("mark0:doit方法中的输出"+in.y);
16         in.y=4;            //必须通过内部类实例对象访问
17         return new innerClass();
18     }
19     public static void main(String[] args){
20         OuterClass out=new OuterClass();
21         OuterClass out1=new OuterClass();
22         OuterClass.innerClass in=out.doit();
23         //通过doit方法实例化内部类对象in
24         //内部类的对象实例化操作必须在外部类或外部类的非静态方法中实现
25         System.out.println("mark1:out.in方法中的输出"+out.in.y);
26         System.out.println("mark2：直接in的输出--??这里输出为什么是20??"+in.y);//这里输出为什么是20??
27 
28         OuterClass.innerClass ina=out1.new innerClass();
29         //或者通过外部类的实例对象调用内部类的构造方法
30         System.out.println("mark3:out1.in方法中的输出"+out1.in.y);
31         System.out.println("mark4：直接ina的输出"+ina.y);
32     }
33 }

 1 public class TheSameName {
 2     private int x;
 3     private class Inner{
 4         private int x=9;
 5         public void doit(int x){
 6             x++;        //调用方法的形参x
 7             this.x++;   //调用内部类的变量x
 8             TheSameName.this.x++;   //调用外部类的变量x
 9         }
10     }
11 }

 1 public class SellOutClass {
 2     private String name;     //定义成员变量
 3     public SellOutClass(){   //定义构造函数
 4         name="苹果";
 5     }
 6     public void sell(int price){   //定义成员方法
 7         class Apple{               //定义局部内部类
 8             int innerPrice=0;       //局部内部类的成员变量
 9             public Apple(int price){ //局部内部类的构造方法
10                 innerPrice=price;
11             }
12             public void price(){     //局部内部类的成员方法
13                 System.out.println("现在开始销售"+name);
14                 System.out.println("单价为："+innerPrice+"元");
15             }
16         }
17         Apple apple=new Apple(price);//实例化局部内部类
18         apple.price();                 //调用局部内部类的方法
19     }
20     public static void main(String[] args){
21         SellOutClass sample=new SellOutClass();//创建实例化对象
22         sample.sell(100);  //通过该对象调用SellOutClass的方法
23     }
24 
25 }

 1 public class OutString {
 2 
 3     public static void main(String[] args) {
 4         final String sourceStr="Ji Lin  Province !";
 5         IStringDeal s=new IStringDeal(){   //编写匿名内部类
 6             @Override                //重写接口的方法  
 7             public String filterBlankChar(){
 8                 String convertStr=sourceStr;
 9                 convertStr=convertStr.replaceAll(" ","");
10                 return convertStr;
11             }
12         };                    //注意这里要加分号
13         System.out.println("源字符串："+sourceStr);
14         System.out.println("转换后的字符串："+s.filterBlankChar());
15     }
16 }

1 //定义接口
2 public interface IStringDeal {
3     public String filterBlankChar();
4 }

class A{
       class B{
       }
}//创建A的内部类B

public class OutputInnerClass extends A.B{
        public OutputInnerClass(A a){
            a.super();
        }
}