黑马程序员_Java语言_面向对象_内部类

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

10.01_面向对象(package关键字的概述及作用)

• A:为什么要有包
  
  • 将字节码(.class)进行分类存放
• B:包的概述//相当于文件夹
• C:包的作用

10.02_面向对象(包的定义及注意事项)

• A:定义包的格式
  
  • package 包名;
  • 定义包
    关键字 package 包名;
    包名：字母全部小写，如果是多级包 使用.分开
    package cn.itcast.test

class A{}   cn.itcast.test.A   package定义包，整个文件的最上方   包是不能重复定义的，只能写一次

• 多级包用.分开即可
• B:定义包的注意事项
  
  • A:package语句必须是程序的第一条可执行的代码
  • B:package语句在一个java文件中只能有一个
  • C:如果没有package，默认表示无包名
  • C:案例演示
  • 包的定义及注意事项

10.03_面向对象(带包的类编译和运行)

• A:如何编译运行带包的类
  
  • a:javac编译的时候带上-d即可
    
    • javac -d . HelloWorld.java
  • b:通过java命令执行。
    
    • java 包名.HellWord

10.04_面向对象(不同包下类之间的访问)

• A:案例演示
  
  • 不同包下类之间的访问

/*  定义包，  写类，调用别的包中的类的方法*/package packa;import packb.PackB;class  PackA{    public static void main(String[] args)     {        PackB pb = new PackB();        pb.show();    //  packc.PackC pc = new packc.PackC();    //  pc.haha();    //  System.out.println("Hello World!");    }}package packb;public class PackB extends packc.PackC{    public PackB(){}    public void show(){       System.out.println("packb...show");       haha();     }}package packc;public class PackC {    //受保护的权限，只给子类使用        protected void haha(){           System.out.println("c类方法haha");        }}

10.05_面向对象(import关键字的概述和使用)

• A:案例演示

  • 为什么要有import//从JDK1.4开始，每个类，默认 import java.lang.*;

• B:导包格式

  • import 包名;
  • 注意：
  • 这种方式导入是具体到类的名称。
  • 虽然可以最后写 .*，但是不建议。
• C:package,import,class有没有顺序关系(面试题)
  
  • 依次

10.06_面向对象(四种权限修饰符的测试)

• A:案例演示
  
  • 四种权限修饰符
• B:结论
• 
  本类 同一个包下(子类和无关类) 不同包下(子类) 不同包下(无关类)
  private Y
  默认 Y Y
  protected Y Y Y
  public Y Y Y Y

10.07_面向对象(类及其组成所使用的常见修饰符)

• A:修饰符：
  
  • 权限修饰符：private，默认的，protected，public
  • 状态修饰符：static，final
  • 抽象修饰符：abstract

• B:类：

  • 权限修饰符：默认修饰符，public
  • 状态修饰符：final

  • 抽象修饰符：abstract

  • 用的最多的就是：public

• C:成员变量：

  • 权限修饰符：private，默认的，protected，public

  • 状态修饰符：static，final

  • 用的最多的就是：private

• D:构造方法：

  • 权限修饰符：private，默认的，protected，public

  • 用的最多的就是：public

• E:成员方法：

  • 权限修饰符：private，默认的，protected，public
  • 状态修饰符：static，final

  • 抽象修饰符：abstract

  • 用的最多的就是：public

• F:除此以外的组合规则：

  • 成员变量：public static final
  • 成员方法：
    
    • public static
    • public abstract
    • public final

10.08_面向对象(内部类概述和访问特点)

• A:内部类概述//在一个类的内部，定义一个类
• B:内部类访问特点
  
  • a:内部类可以直接访问外部类的成员，包括私有。
  • b:外部类要访问内部类的成员，必须创建对象。
• C:案例演示
  
  • 内部类极其访问特点

/*  成员内部类的使用格式*/class Outer{    int i = 3 ;      class Inner    {        int i = 4;        public  void show(){           int i = 5;           System.out.println("inner.show"+Outer.this.i);        }    }}class InnerClassDemo {    public static void main(String[] args)     {        //Outer.Inner oi = new Outer.Inner();        //oi.show();        //Outer.Inner.show();        Outer.Inner oi = new Outer().new Inner();        oi.show();        //new Outer().method();        //System.out.println("Hello World!");    }}

10.09_面向对象(成员内部类私有使用)

• private

10.10_面向对象(静态成员内部类)

• static
• B:成员内部类被静态修饰后的访问方式是:
  
  • 外部类名.内部类名 对象名 = new 外部类名.内部类名();

    格式1 ： 内部类是非静态的，内部类的方法是非静态的    外部类.内部类  变量 = new 外部类对象().new内部类对象();    变量.内部类方法();    格式2： 内部类静态，内部类方法静态    外部类.内部类.内部类方法();    格式3： 内部类是静态的，内部类方法非静态    外部类.内部类 变量 = new 外部类.内部类对象();

10.11_面向对象(成员内部类的面试题)

• A:面试题

• 要求：使用已知的变量，在控制台输出30，20，10。class Outer {    public int num = 10;    class Inner {        public int num = 20;        public void show() {            int num = 30;            System.out.println(?);//num            System.out.println(??);//this.num            System.out.println(???);//Outer.this.num        }    }}class InnerClassTest {    public static void main(String[] args) {        Outer.Inner oi = new Outer().new Inner();        oi.show();    }   }

10.12_面向对象(局部内部类访问局部变量的问题)

• A:案例演示
  
  • 局部内部类访问局部变量必须用final修饰

生命周期： 对象生存时间大于方法的局部生存时间  加final后，可以访问，但是变量的生命定义的区间有关，和是不是final没有任何关系  为什么加final可以通过，javac编译，变了戏法，变量值直接赋值到方法中

jdk1.8不需要final了

10.13_面向对象(匿名内部类的格式和理解)

• A:匿名内部类
  
  • 就是内部类的简化写法。
• B:前提：必须有继承类，或者实现接口
  
  • 这里的类可以是具体类也可以是抽象类。
• C:格式：
• 
  new 类名或者接口名(){
  重写方法;
  }
• D:本质是什么呢?
  
  • 是一个继承了该类或者实现了该接口的子类匿名对象。
• E:案例演示
  
  • 按照要求来一个匿名内部类

 interface Inter{     public abstract void show();     public abstract void show2();  }/*  class InterImpl implements Iner{     public void show(){     }  }  main(){    new InterImpl().show();  }  匿名内部类，简化上面的书写  匿名内部类写在一个类的方法中*/class Outer{    public void method(){      //匿名内部类，简化书写      //new开始到分号结束，直接看成是接口的实现类的一个对象    Inter i =  new Inter(){        public void show(){           System.out.println("重写接口show");        }        public void show2(){             System.out.println("重写接口show2");        }      };      i.show();      i.show2();    }}class NiMingDemo {    public static void main(String[] args)     {        Outer o = new Outer();        o.method();        System.out.println("Hello World!");    }}

10.14_面向对象(匿名内部类的方法调用)

• A:案例演示
  
  • 匿名内部类的方法调用

interface A{    public abstract void a();}class AImpl implements A{    public void a(){       System.out.println("重写接口A方法");    }}class NiMingTest{    public  A  getA(){       //匿名内部类，实现结果      return new A(){         public void a(){            System.out.println("匿名内部类");         }       };    }}class NiMingDemo1 {    public static void main(String[] args)     {        NiMingTest n = new NiMingTest();        A a = n.getA();        a.a();        //System.out.println("Hello World!");    }}

10.15_面向对象(匿名内部类在开发中的应用)

• A:代码如下

• //这里写抽象类，接口都行abstract class Person {    public abstract void show();}class PersonDemo {    public void method(Person p) {        p.show();    }}class PersonTest {    public static void main(String[] args) {        //如何调用PersonDemo中的method方法呢?        PersonDemo pd = new PersonDemo ();        //见下    }}

pd.method(new Person() {            public void show() {                System.out.println("ss");            }        });

10.16_面向对象(匿名内部类的面试题)

• A:面试题
• 
  按照要求，补齐代码
  interface Inter { void show(); }
  class Outer { //补齐代码 }
  class OuterDemo {
  public static void main(String[] args) {
  Outer.method().show();
  }
  }
  要求在控制台输出”HelloWorld”

public static Inter method() {        return new Inter() {            public void show() {                System.out.println("HelloWorld");            }        };