Java基础部分第十节

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

• 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.05_面向对象(import关键字的概述和使用)(掌握)

• A:案例演示
  
  • 为什么要有—-import
    
    • 其实就是让有包的类对调用者可见,不用写全类名了
• B:导包格式
  
  • import 包名;
  • 注意：
  • 这种方式导入是到类的名称。
  • 虽然可以最后写*，但是不建议。
  • 开发时一般都是导入具体的类
• C:package>>>>import>>>>>class有没有顺序关系(面试题)
• 有，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:案例演示
  
  • 内部类极其访问特点 *
    public class Demo {
    public static void main(String[] args) {
    //inner i= new inner(); 出错，找不到符号
    //i.metchod();
    //外部类名.内部类名 对象 = 外部类对象（）.内部类对象（）；
    outer.inner oi=new outer().new inner ();//创建内部类成员
    oi.metchod();
    }
    }
    class outer{
    private int num =10;
    class inner{
    public void metchod(){
    System.out.print(“你好”);
    }
    }
    }

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

• private 直接创建对象已经没有办法调用了，在本类中写一个方法，外部调用方法，由方法调用

10.10_面向对象(静态成员内部类，看做静态的成员)(了解)

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

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

• A:面试题
• //内部类之所以可以获取到外部的成员，是因为他能获取带外部类的引用外部类名.this

• 要求：使用已知的变量，在控制台输出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_面向对象(局部内部类访问局部变量的问题)(掌握)———–看的不是特别明白day10-13

• A:案例演示

  • 局部内部类访问局部变量必须用final修饰

  • 局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
    因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用

    但是jdk1.8取消了这个事情,所以我认为这是个bug

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

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

10.14_面向对象(匿名内部类重写多个方法调用)

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

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 ();    }}

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

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