包,修饰符,内部类

目录

包的特点:

权限修饰符

内部类

成员内部类

局部内部类

匿名内部类

---

包的特点:

• 可以有多层
• 不同包下的文件名可以重复
• 包的声明必须是第一行代码

• 相同包下的类可以直接访问,不需要其他操作
• 不同包之间下的类相互访问必须使用类的全名(包名.类名)  或  使用import将类导入

注意:*代表的是通配符,表示导入这个包下的所有类,但没有导入子包下的类

权限修饰符

• public: 当前类,相同包不同类,不同包下的类
• default: 当前类,相同包下不同的类              当前包下使用
• protected: 当前类,相同包下不同的类          让子类对象使用
• private: 当前类

	public	protected	default	private
同一类中	√	√	√	√
同一包中(子类与无关类)	√	√	√
不同包的子类	√	√
不同包中的无关类	√

---

 

   

修饰符总结
修饰符	类	成员变量	成员方法	构造方法
public	Y	Y	Y	Y
default	Y	Y	Y	Y
protected		Y	Y	Y
private		Y	Y	Y
abstract	Y		Y
static		Y	Y
final	Y	Y	Y

常见规则:

• 我们使用public来修饰类,一个Java文件中只能有一个类    如果一个文件有多个类,类名和文件名一样的类名,必须用public修饰类,其他类不能用public修饰
• 所有成员变量都使用private修饰
• 所有方法使用public修饰 ( 私有除外)
• 所有的构造方法用public修饰  (如果不允许创建对象,那么用private修饰)

内部类

• 将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类。
• 一个事物内部还包含其他可能包含的事物

成员内部类

• 在类的成员位置，和成员变量以及成员方法所在的位置是一样的
• 静态内部类就是独立外部类对象存在的，所以静态内部类不能访问外部类的非静态成员，而外部类依然可以访问静态内部类对象的所有访问权限的成员

package CeShi;

/**
 * @author Lzy
 * @creat 2021-01-29-17:00
 */
public class InnerDemo {
    public static void main(String[] args) {
        Outer o = new Outer();//创建外部类对象
        o.method();//通过新建的外部类对象调用方法
        System.out.println("------全名形式调用内部类,需要从外到内建立对象------");
        Outer.Inner i = new Outer().new Inner();
        i.function();
    }
}

class Outer {
    private String str = "我是Outer的私有成员";
    public void method(){
        Inner i = new Inner();//创建内部类对象
        i.function();//通过对象调用方法
    }

    //构造成员内部类  和成员变量以及成员方法位置一样
    class Inner {
        public void function(){
            System.out.println("function");
    //因为这里Inner属于OUter的内部类,且private定义的成员变量在同一类中是可以访问的
            System.out.println(str);
        }
    }
}

成员内部类修饰符

可以使用的修饰符:private,public,procted,final,static,abstract

调用内部类方法时:

 *  可以使用权限修饰符修饰成员内部类，但是如果使用私有来修饰，则无法在其他类中访问

 *  可以使用static修饰成员内部类，不用再创建外部类的对象了  (进一步用static修饰内部方法时,那么就可以直接通过全名调用方法了)

 *  可以使用abstract,final修饰成员内部类    (不常用,因为本身没有使用价值)

package CeShi;

/**
 * @author Lzy
 * @creat 2021-01-29-20:17
 */
public class InnerDemo2 {
    public static void main(String[] args) {
        Outer2.Inner2.funcation();//直接通过全名调用方法,无需创建对象
    }
}

class Outer2 {
//内部类与内部类方法都用static修饰
    static class Inner2 {
        public static void funcation() {
            System.out.println("我是内部类方法输出");
        }
    }
}

局部内部类

• 定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问
• 出了方法后无法使用                 

使用场景不多

package CeShi;

/**
 * @author Lzy
 * @creat 2021-01-29-20:46
 */
public class InnerDemo3 {
    public static void main(String[] args) {
       Outer3 o = new Outer3();
       o.method();//创建外部类对象并调用外部类方法
    }
}

class Outer3 {
    public void method(){
        System.out.println("---");
        class Inner3 {
            public void function() {
                System.out.println("我是局部内部类输出");
            }
        }
        Inner3 i = new Inner3();
        i.function();//必须在内部类声明后再创建对象调用方法
    }
}

匿名内部类

•  可以当作一个没有名字的局部内部类
• 必须定义在方法中
• 必须在定义时候创建它的对象

package CeShi;

/**
 * @author Lzy
 * @creat 2021-01-31-13:23
匿名内部类:通过创建实现接口的子类对象完成*/
public class InnerDemo4 {
    public static void main(String[] args) {
        Outer4 o = new Outer4();
        o.method();
    }
}

interface Inner {
    public void function();
}

class Outer4 {
    public void method() {
        new Inner() {
            @Override
            public void function() {
                System.out.println("我是匿名内部类输出");
            }
        }.function();//只能调用一次
    }
}

                                               

package CeShi;

/**
 * @author Lzy
 * @creat 2021-01-31-13:23
匿名内部类:创建匿名内部类对象赋值给父接口变量,然后通过该变量调用方法,主方法再调用外部类*/
public class InnerDemo4 {
    public static void main(String[] args) {
        Outer4 o = new Outer4();
        o.method();
    }
}

interface Inner {
    public void function();
}

class Outer4 {
    public void method() {

        Inner i = new Inner() {
            @Override
            public void function() {
                System.out.println("我是匿名内部类输出,用于赋值外部参数调用");
            }
        };
        i.function();//作为成员变量可多次调用方法
        i.function();
    }
}

 

使用场景

作为参数进行传递  (意味着使用一个新的对象实现接口时不用再新建一个类,可以直接在匿名内部类中定义)

匿名内部类适合创建那种只需要使用一次的类，也就是说创建一个匿名内部类，只需要用一次即可。

package lei;

interface Student {
    public abstract void study();
}

package lei;

/**
 * @author Lzy
 * @creat 2021-01-31-14:09
 通过接口，创建实现该接口的对象，然后重写了这个接口中的方法*/
public class InnerDemo5 {
    public static void method(Student s){
        s.study();
    }
    public static void main(String[] args) {
        method(
                new Student() {

                    @Override
                    public void study() {
                        System.out.println("敲代码");
                    }
                }
        );
    }
}