首页 > 代码库 > 10 面向对象(package关键字的概述及作用)

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

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

  • A:为什么要有包
    *开发时有很多类,如果放在一个文件夹中不方便管理,而且容易重复
    • 将字节码(.class)进行分类存放
    • 包其实就是文件夹
  • B:包的概述
  • 举例:
    学生:增加,删除,修改,查询
    老师:增加,删除,修改,查询

    方案1:按照功能分
        com.heima.add
            AddStudent
            AddTeacher
        com.heima.delete
            DeleteStudent
            DeleteTeacher
        com.heima.update
            UpdateStudent
            UpdateTeacher
        com.heima.find
            FindStudent
            FindTeacher
    
    方案2:按照模块分
        com.heima.teacher
            AddTeacher
            DeleteTeacher
            UpdateTeacher
            FindTeacher
        com.heima.student
            AddStudent
            DeleteStudent
            UpdateStudent
            FindStudent
    

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

  • A:定义包的格式
    • package 包名;
    • 多级包用.分开即可
  • B:定义包的注意事项
    • A:package语句必须是程序的第一条可执行的代码
    • B:package语句在一个java文件中只能有一个
    • C:如果没有package,默认表示无包名
  • C:案例演示
    • 包的定义及注意事项
      案例:
      package com.heima;
      class Demo1_Package {
      public static void main(String[] args) {
      System.out.println("Hello World!");
      }
      }

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

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

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

  • A:案例演示
    • 不同包下类之间的访问
      案例:
      package com.heima;
      class Demo1_Package {
      public static void main(String[] args) {
      com.baidu.Person p = new com.baidu.Person("张三",23);
      System.out.println(p.getName() + "…" + p.getAge());
      }
      }
      package com.baidu;
      public class Person {
      private String name;
      private int age;
      public Person(){}
      public Person(String name,int age) {
      this.name = name;
      this.age = age;
      }
      public void setName(String name) {
      this.name = name;
      }
      public String getName() {
      return name;
      }
      public void setAge(int age) {
      this.age = age;
      }
      public int getAge() {
      return age;
      }
      }

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

  • A:案例演示
    • 为什么要有import ctl,shif+o也可以导包
      • 其实就是让有包的类对调用者可见,不用写全类名了
        *导包后Person类对于Demo1_Package就可见了
  • B:导包格式
    • import 包名;
    • 注意:
    • 这种方式导入是到类的名称。
    • 虽然可以最后写*,但是不建议。
  • C:package,import,class有没有顺序关系(面试题)package必须第一句,只有一个,然后是import,可以有多句,然后是class
    案例:
    package com.heima;
    import com.baidu.Person;
    import com.xxx.Student;
    //import java.util.Scanner; //在开发中我们用的都是导入具体的类
    import java.util.; //代表通配符,他会到该包下挨个匹配,匹配上就导入
    class Demo1_Package {
    public static void main(String[] args) {
    Person p = new Person("张三",23);
    System.out.println(p.getName() + "…" + p.getAge());
    //p.print(); //在不同包下的无关类,不允许访问,因为是protected修饰的
    /Scanner sc = new Scanner(System.in);
    int x = sc.nextInt();
    System.out.println(x);
    /
    }
    }
    package com.baidu;
    public class Person {
    private String name;
    private int age;
    public Person(){}
    public Person(String name,int age) {
    this.name = name;
    this.age = age;
    }
    public void setName(String name) {
    this.name = name;
    }
    public String getName() {
    return name;
    }
    public void setAge(int age) {
    this.age = age;
    }
    public int getAge() {
    return age;
    }
    }

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

*封装:隐藏实现细节,对外提供公共的访问方式

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

    案例:
    package com.heima;
    import com.baidu.Person;
    import com.xxx.Student;
    //import java.util.Scanner; //在开发中我们用的都是导入具体的类
    import java.util.; //代表通配符,他会到该包下挨个匹配,匹配上就导入
    class Demo1_Package {
    public static void main(String[] args) {
    Person p = new Person("张三",23);
    System.out.println(p.getName() + "…" + p.getAge());
    //p.print(); //在不同包下的无关类,不允许访问,因为是protected修饰的
    /Scanner sc = new Scanner(System.in);
    int x = sc.nextInt();
    System.out.println(x);
    /

    Student s = new Student("李四",24);
    System.out.println(s.getName() + "..." + s.getAge());
    s.method();
    

    }
    }
    package com.baidu;
    public class Person {
    private String name;
    private int age;
    public Person(){}
    public Person(String name,int age) {
    this.name = name;
    this.age = age;
    }
    public void setName(String name) {
    this.name = name;
    }
    public String getName() {
    return name;
    }
    public void setAge(int age) {
    this.age = age;
    }
    public int getAge() {
    return age;
    }
    protected void print() {
    System.out.println("print");
    }
    }
    package com.xxx;
    import com.baidu.Person;
    public class Student extends Person {
    public Student(){}
    public Student(String name,int age) {
    super(name,age);
    }
    public void method() {
    print();
    }
    }

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 Demo1_InnerClass {
      public static void main(String[] args) {
      //Inner i = new Inner();
      //i.method();
      //外部类名.内部类名 = 外部类对象.内部类对象
      Outer.Inner oi = new Outer().new Inner(); //创建内部类对象,这样其实外部类对象也创建了
      oi.method();
      }
      }
      class Outer {
      private int num = 10;
      class Inner {
      public void method() {
      System.out.println(num);
      }
      }
      }

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

  • private:在外部不能直接创建内部类对象了
    案例:
    class Demo2_InnerClass {
    public static void main(String[] args) {
    //Outer.Inner oi = new Outer().new Inner();
    //oi.method();
    Outer o =
    new Outer();
    o.print();
    }
    }
    class Outer {
    private int num = 10;
    private class Inner {//这个时候不可以在其他类里面使用Inner类,私有的
    public void method() {
    System.out.println(num);
    }
    }
    public void print() {
    Inner i = new Inner();
    i.method();
    }
    }

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

  • static
  • B:成员内部类被静态修饰后的访问方式是:
    • 外部类名.内部类名 对象名 = 外部类名.内部类对象;
      Outer.Inner oi = new Outer().new Inner();这是在普通成员类中,用来两个new实际创建了两个对象,一个内部类对象,一个外部类对象,注意其中有两个()分别调用了两个类的构造函数,
      Outer.Inner oi1 = new Outer.Inner(); 这是在静态成员类中只能用类名.内部类名的方式来,并且这种情况下只创建了一个内部类对象,没有创建外部类对象,因为只用了一个new
      案例:
      class Demo1_InnerClass {
      public static void main(String[] args) {
      //外部类名.内部类名 对象名 = 外部类名.内部类对象;
      Outer.Inner oi = new Outer.Inner();//静态内部类必须要这样创建,其实只创建了内部类对象;
      oi.method();
      Outer.Inner2.print();//类名加.的方式进行
      }
      }
      class Outer {
      static class Inner {
      public void method() {
      System.out.println("method");
      }
      }
      static class Inner2 {
      public static void print() {
      System.out.println("print");
      }
      }
      }

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,内部类之所以能够访问外部类成员,因为它能获取外部类的引用Outer.this,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修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用

      但是jdk1.8取消了这个事情,所以我认为这是个bug
      案例:
      class Demo1_InnerClass {
      public static void main(String[] args) {
      Outer o = new Outer();
      o.method();
      }
      }
      //局部内部类
      class Outer {
      public void method() {
      final int num = 10;
      class Inner {//局部内部类和局部变量一样,只在方法中有效,出了方法就无效了
      public void print() {
      System.out.println(num);
      }
      }
      Inner i = new Inner();
      i.print();
      }
      /public void run() {
      Inner i = new Inner(); //局部内部类,只能在其所在的方法中访问
      i.print();
      }
      /
      }

技术分享

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

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

    • 按照要求来一个匿名内部类
      案例:
      class Demo1_NoNameInnerClass {
      public static void main(String[] args) {
      Outer o = new Outer();
      o.method();
      }
      }
      interface Inter {
      public void print();
      }
      class Outer {
      class Inner implements Inter {
      public void print() {
      System.out.println("print");
      }
      }
      public void method(){
      //Inner i = new Inner();
      //i.print();
      //new Inner().print();
      //Inter i = new Inner(); //父类引用指向子类对象

      new Inter() { //实现Inter接口
      public void print() { //重写抽象方法
      System.out.println("print");
      }
      }.print();
      }
      }

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

  • A:案例演示
    • 匿名内部类的方法调用
      案例:
      class Demo2_NoNameInnerClass {
      public static void main(String[] args) {
      Outer o = new Outer();
      o.method();
      }
      }
      interface Inter {
      public void show1();
      public void show2();
      }
      //匿名内部类只针对重写一个方法时候使用,否则太麻烦了
      class Outer {
      public void method() {
      /new Inter(){
      public void show1() {
      System.out.println("show1");
      }
      public void show2() {
      System.out.println("show2");
      }
      }.show1();
      new Inter(){
      public void show1() {
      System.out.println("show1");
      }
      public void show2() {
      System.out.println("show2");
      }
      }.show2();
      /
      Inter i = new Inter(){
      public void show1() {
      System.out.println("show1");
      }
      public void show2() {
      System.out.println("show2");
      }
      /public void show3() {
      System.out.println("show3");
      }
      /
      };
      i.show1();
      i.show2();
      //i.show3(); //匿名内部类是不能向下转型的,因为没有子类类名
      }
      }

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 ();
            //请在此处补充代码
        }
    }

答案:
class Test1_NoNameInnerClass {
public static void main(String[] args) {
//如何调用PersonDemo中的method方法呢?
PersonDemo pd = new PersonDemo ();
//pd.method(new Student());
pd.method(new Person() {
public void show() {
System.out.println("show");//匿名对象类作为参数传递
}
});
}
}
//这里写抽象类,接口都行
abstract class Person {
public abstract void show();
}
class PersonDemo {

//public void method(Person p) {        //Person p = new Student();     //父类引用指向子类对象
/*
Person p = new Person(){
    public void show() {
        System.out.println("show");
    }
};
*/
public void method(Person p) {
    p.show();
}

}
class Student extends Person {
public void show() {
System.out.println("show");
}
}

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

  • A:面试题
  • 按照要求,补齐代码
    interface Inter { void show(); }
    class Outer { //补齐代码 
    

}
class OuterDemo {
public static void main(String[] args) {
Outer.method().show();
/*分析:outer中必须有method方法,并且这个方法返回值一定是Iter的实现类对象

*/

          }
    }

}
要求在控制台输出”HelloWorld”
答案:
class Test2_NoNameInnerClass {
public static void main(String[] args) {
//Outer.method().show(); //链式编程,每次调用方法后还能继续调用方法,证明调用方法返回的是对象,.show说明调用了这份方法,那么这份方法必须被重写
// Inter i = Outer.method();
// i.show();
}
}

interface Inter {
void show(); //这是接口,要调用这个方法必须进行重写
}

class Outer {
//补齐代码
public static Inter method() {//返回值必须是Inter对象,要调用show,必须对show重写
return new Inter() {//匿名类对象格式:
public void show() {
System.out.println("HelloWorld");
}
};
}
}

//要求在控制台输出”HelloWorld”//按照要求,补齐代码

10.17_day10总结

  • 把今天的知识点总结一遍。


来自为知笔记(Wiz)


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