包,修饰符,内部类
目录
包的特点:
- 可以有多层
- 不同包下的文件名可以重复
- 包的声明必须是第一行代码
- 相同包下的类可以直接访问,不需要其他操作
- 不同包之间下的类相互访问必须使用类的全名(包名.类名) 或 使用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("敲代码");
}
}
);
}
}
查看24道真题和解析
