Java面向对象 Li.031

Package

• 包只能类的首行 com.lizica.java
• 默认编译是不会创建包的文件夹, 加入参数 -d .才会创建
• 运行类的方式就变了, 必须带上包的路径才的运行类

javac -d . Demo1_Package.java
java com.lizicai.java.Demo1_Package

package com.lizicai.java;
public class Demo1_Package {
    public static void main(String[] args) {
        System.out.println("hello");
    }
}

• 引用时候3种方式, 推荐导入具体的类,第2种

class Demo2_Package{
    public static void main(String[] args) {
        com.lizicai.java.Demo1_Package d = new com.lizicai.java.Demo1_Package();
        d.sprint();
    }
}

import com.lizicai.java.Demo1_Package;
class Demo2_Package{
    public static void main(String[] args) {
        Demo1_Package d = new Demo1_Package();
        d.sprint();
    }
}

import com.lizicai.java.*;
class Demo2_Package{
    public static void main(String[] args) {
        Demo1_Package d = new Demo1_Package();
        d.sprint();
    }
}

不同类修饰符 和 包访问关系

类修饰符	本类	同一个包下(子类和无关系)	不同包下(子类)	不同包下(无关系)
private
默认
protected
public

Java 修饰符总结

修饰符

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

类的修饰符

• 权限修饰符：默认修饰符，public

• 状态修饰符：final

• 抽象修饰符：abstract

• 用的最多的就是：public

成员变量的修饰符

• 权限修饰符：private，默认的，protected，public
• 状态修饰符：static，final
• 用的最多的就是：private

构造方法的修饰符

• 权限修饰符：private，默认的，protected，public
• 用的最多的就是：public

成员方法

• 权限修饰符：private，默认的，protected，public
• 状态修饰符：static，final
• 抽象修饰符：abstract
• 用的最多的就是：public

组合规则

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

内部类

public class Demo3_Iner {
    public static void main(String[] args) {
        Outer.Inner aa = new Outer().new Inner();
        aa.method();
    }
}
class Outer{
    class Inner{
        public void method(){
            System.out.println("InerClass");
        }
    }
}

静态内部类

public class Demo4_StaticInner {
    public static void main(String[] args) {
        Outer.Inner aa = new Outer.Inner();
        aa.method();
    }
}
class Outer{
    static class Inner{
        public void method(){
            System.out.println("InerClass");
        }
    }
}

内部类调用外部类成员

public class Demo5_Inner {
    public static void main(String[] args) {
        Outer.Inner o = new Outer().new Inner();
        o.method();
    }
}
class Outer{
    private int num = 30;
    class Inner{
        private int num = 20;
        public void method(){
            int num = 10;
            System.out.println(num);
            System.out.println(this.num);
            System.out.println(Outer.this.num);
        }
        public int getNum() {
            return num;
        }
    }
    //外部类调用内部类成员
    public void test(){
        Inner n = new Inner();
        System.out.println(n.getNum());
    }
}

public class Demo7_Inner {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.printe();
    }
}
interface Inter1{
    public void method();
}
class Outer{
    class Inner implements Inter1{
        public void method(){
            System.out.println("LLL");
        }
    }
    public void printe(){
        Inner i = new Inner();
        i.method();
    }
}

匿名内部类, 只能放在方法内, 推荐只有一个方法的类才使用匿名内部类.

public class Demo8_Inner {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.test();
    }
}
interface Inter2{
    public void method();
    public void method2();
}
class Outer{
    public void test(){
        new Inter2(){
            public void method(){
                System.out.println("HHH");
            }
            public void method2(){
                System.out.println("KKK");
            }
        }.method();
        new Inter2(){
            public void method(){
                System.out.println("HHH");
            }
            public void method2(){
                System.out.println("KKK");
            }
        }.method2();
    }
}

public class Demo9_Inner {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.test();
    }
}
interface Inter2{
    public void method();
    public void method2();
}
class Outer{
    public void test(){
        Inter2 i = new Inter2(){
            public void method(){
                System.out.println("HHH");
            }
            public void method2(){
                System.out.println("KKK");
            }
        };
        i.method();
        i.method2();
    }
}

匿名内部类当作参数使用

public class Demo10_Inner {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method(new Inter(){
            public void method(){
                System.out.println("NoName");
            }
        });
    }
}
interface Inter{
    public void method();
}
class Outer {
    public void method(Inter i){
        i.method();
    }
}

匿名内部类当前返回类型使用

public class Demo11_Inner {
    public static void main(String[] args) {
        Outer.method().show();
    }
}
interface Inter{
    public void show();
}
class Outer {
    public static Inter method(){
        return new Inter(){
            public void show(){
                System.out.println("HaHaHa...");
            }
        };
    }
}

面向对象(成员变量和局部变量的区别)

在类中的位置不同

• 成员变量: 在类中方法外
• 局部变量: 在方法宣言中或者方法声明上

在内存中位置不同

• 成员变量: 在堆内存(成员变量属于对象, 对象进堆内存)
• 局部变量: 在栈内存(局部变量属于方法, 方法进栈内存)

生命周期不同

• 成员变量: 随着对象的创建而存在, 随着对象的消失而消失
• 局部变量: 随着方法的调用而存在, 随着方法的调用完毕而消失

初始化值不同

• 成员变量: 有默认初始化值
• 局部变量: 没有默认初始化值, 必须定义, 赋值, 然后才能使用.

注意事项

• 局部变量名称可以和成员变量名称一样, 在方法中使用的时候, 采用的是就近原则
• 基本数据类型变量包括哪些: byte,short,int,long,float,double,boolean,char
• 线上服务数据类型变量包括哪些: 数组, 类, 接口, 枚举

静态代码块 构造代码块 构造方法搜索顺序

public class FuZi {
    public static void main(String[] args) {
        Fu f = new Zi();
    }
}
class Fu{
    static {
        System.out.println("Fu static");
    }

    {
        System.out.println("Fu 构造代码块");
    }

    Fu(){
        System.out.println("Fu 构造方法");
    }
}

class Zi extends Fu{
    static {
        System.out.println("Zi static");
    }

    {
        System.out.println("Zi 构造代码块");
    }

    Zi(){
        System.out.println("Zi 构造方法");
    }
}

Fu static
Zi static
Fu 构造代码块
Fu 构造方法
Zi 构造代码块
Zi 构造方法

面向对象( 方法重写概述及其应用 )

方法重写是什么

子父类出现一模一样的方法( 注意: 值返回值类型可以是子父类)

方法重写的应用

当子类需要父类的功能, 而功能主体子类有自己的特有内容时, 可以重写父类中的方法

方法重写注意事项

• 父类中私有方法不能被重写, 因为父类私有方法子类根本无法继承

• 子类重写父类方法时, 访问权限不能更低, 最好一致

• 父类静态方法, 子类也必须通过静态方法进行重写,( 其实是静态的覆盖 )

抽象类

• 抽象类必须是abstract 修饰

• 抽象方法必须有abstract 修饰

• 抽象类不一定有抽象方法(可以全是非抽象方法), 有抽象方法的一定是抽象类或者接口

• 抽象类不能实例化, 可以由继承的子类实例化

• 抽象类的子类要么是抽象类要么实现全部接口的非抽象类

抽象类成员特点

• 抽象类成员特点: 既可以是变量也可以是常量, abstract 不能修饰成员变量

• 构造方法: 有, 用于子类访问父类数据的初始化.

• 成员方法, 既可以是抽象的, 也可以是非抽象的.