Java 面向对象 05

面向对象·五级

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

包的定义及注意事项

* A:定义包的格式

    * package 包名;

    * 多级包用   .   分开即可

* B:定义包的注意事项

    * a: package语句必须是程序的第一条可执行的代码

    * b: package语句在一个java文件中只能有一个

    * c: 如果没有package，默认表示无包名

* C:案例演示

    * 包的定义及注意事项

/*
* A:定义包的格式
    * package 包名;
    * 多级包用.分开即可
* B:定义包的注意事项
    * A:package语句必须是程序的第一条可执行的代码
    * B:package语句在一个java文件中只能有一个
    * C:如果没有package，默认表示无包名
*/
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();
    }
}

带包的类编译和运行

* A:如何编译运行带包的类

    * a:javac编译的时候带上-d即可

        * javac -d . HelloWorld.java

    * b:通过java命令执行。

        * java 包名.HellWord

import关键字的概述和使用

* A:案例演示

    * 为什么要有import

        * 其实就是让有包的类对调用者可见,不用写全类名了

* B:导包格式

    * import 包名;

    * 注意：

    * 这种方式导入是到类的名称。

    * 虽然可以最后写*，但是不建议。

* C:package,import,class有没有顺序关系(面试题)

---

四种权限修饰符的测试

* A:案例演示

    * 四种权限修饰符

* B:结论

本类        同一个包下(子类和无关类)    不同包下(子类)    不同包下(无关类)

        private           Y        

        默认               Y            Y

        protected       Y            Y                                                Y

        public             Y            Y                                                Y                           Y

类及其组成所使用的常见修饰符

* A:修饰符：

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

    * 状态修饰符：static，final

    * 抽象修饰符：abstrac

* 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

---

内部类概述和访问特点

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

    }
}

/*
* A:内部类概述
* B:内部类访问特点
    * a:内部类可以直接访问外部类的成员，包括私有。
    * b:外部类要访问内部类的成员，必须创建对象。
    * 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
* C:案例演示
    * 内部类极其访问特点
*/

class Outer {
    private int num = 10;
    class Inner {
        public void method() {
            System.out.println(num);
        }
    }
}

静态成员内部类

* A: static

* B: 成员内部类被静态修饰后的访问方式是:

    * 外部类名.内部类名 对象名 = 外部类名.内部类对象;

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

成员内部类的面试题

* A:面试题

* 要求：使用已知的变量，在控制台输出30，20，10。

class Test1_InnerClass {
    public static void main(String[] args) {
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }
}
//要求：使用已知的变量，在控制台输出30，20，10。
//内部类之所以能获取到外部类的成员,是因为他能获取到外部类的引用外部类名.this
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);
        }
    }
}

局部内部类访问局部变量的问题

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

匿名内部类的格式和理解

* A:匿名内部类

    * 就是内部类的简化写法。

* B:前提：存在一个类或者接口

    * 这里的类可以是具体类也可以是抽象类。

* C:格式：

        new 类名或者接口名(){

            重写方法;

        }

* D:本质是什么呢?

    * 是一个继承了该类或者实现了该接口的子类匿名对象。

* E:案例演示

    * 按照要求来一个匿名内部类

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

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

匿名内部类重写多个方法调用

* 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();                        //匿名内部类是不能向下转型的,因为没有子类类名
    }
}

class Demo3_Con {
    public static void main(String[] args) {
        Person p = new Person();
        //p.Person();
    }
}

class Person {
    //public void Person() {                        //不是构造方法,是一个普通方法
    public Person() {
        System.out.println("Hello World!");
    }
}

class Demo4_Override {
    public static void main(String[] args) {

    }
}

class Person {
    public void print() {
        System.out.println("Person");
    }
}

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

class Father {
    public Person method() {
        return new Person();
    }
}

class Son extends Father {
    public Student method() {
        return new Student();
    }
}

匿名内部类在开发中的应用

匿名内部类的面试题

class Test2_NoNameInnerClass {
    public static void main(String[] args) {
        //Outer.method().show();            //链式编程,每次调用方法后还能继续调用方法,证明调用方法返回的是对象
        Inter i = Outer.method();
        i.show();
    }
}
//按照要求，补齐代码
interface Inter {
    void show();
}

class Outer {
    //补齐代码
    public static Inter method() {
        return new Inter() {
            public void show() {
                System.out.println("show");
            }
        };
    }
}

//要求在控制台输出”HelloWorld”