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();
    }
}
View Code
复制代码
复制代码
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");
    }
}
View Code
复制代码
复制代码
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();
    }
}
View Code
复制代码

 

带包的类编译和运行

* 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);
        }
    }
}
View Code
复制代码

 

静态成员内部类

* 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");
        }
    }
}
View Code
复制代码

 

成员内部类的面试题

* 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);
        }
    }
}
View Code
复制代码

 

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

* 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();
    }*/
}
View Code
复制代码

 

匿名内部类的格式和理解

* 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();
    }
}
View Code
复制代码

 

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

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

 

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

View Code

 

匿名内部类的面试题

复制代码
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”
View Code
复制代码

 

posted @   小么VinVin  阅读(116)  评论(0)  编辑  收藏  举报
编辑推荐：
· AI与.NET技术实操系列：基于图像分类模型对图像进行分类
· go语言实现终端里的倒计时
· 如何编写易于单元测试的代码
· 10年+ .NET Coder 心语，封装的思维：从隐藏、稳定开始理解其本质意义
· .NET Core 中如何实现缓存的预热？
阅读排行：
· 25岁的心里话
· 闲置电脑爆改个人服务器（超详细） #公网映射 #Vmware虚拟网络编辑器
· 零经验选手，Compose 一天开发一款小游戏！
· 通过 API 将Deepseek响应流式内容输出到前端
· AI Agent开发，如何调用三方的API Function，是通过提示词来发起调用的吗
点击右上角即可分享
微信分享提示