一、权限修饰符
在java中有四种权限修饰符：范围从大到小分别是：public、protect、default(friendly)、private,它们之间的区别是：
public： Java语言中访问限制最宽的修饰符，一般称之为“公共的”。被其修饰的类、属性以及方法不仅可以跨类访问，而且允许跨包(package)访问。
protect: 介于public 和 private 之间的一种访问修饰符，一般称之为“保护形”。被其修饰的类、属性以及方法只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。
default: 这个访问权限可能是很多人容易所忽视的，即不写任何关键字。默认权限(同包权限)即：包内可访问，包外不可访问，不管是子类还是没有继承关系的类。
private: 只能在当前类中使用，外部不能访问。
在同一个包的前提下，在继承时，子类只能继承父类中的public、protected以及default访问权限的成员变量或方法，并且继承之后，这些成员变量或方法的访问权限和之前的一样，如父类中是public，继承后还是public。
在不同包的前提下，在继承时，子类只继承父类中的public和protected访问权限的成员变量或方法作为子类自己的成员变量或方法。
二、类及其组成可以用的修饰符
修饰符分为三种：权限修饰符、状态修饰符和抽象修饰符。
权限修饰符：private，default，protected，public
状态修饰符：static，final
抽象修饰符：abstract
【类】
权限修饰符：默认修饰符(default)，public
状态修饰符：final
抽象修饰符：abstract
其中，用的最多的是public
【成员变量】
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
用的最多的就是：private
【构造方法】
权限修饰符：private，默认的，protected，public
用的最多的就是：public
【成员方法】
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract
用的最多的就是：public
三、内部类
3.1 内部类概述
把类定义在其他类的内部，这个类就被称为内部类。
举例：在类A中定义了一个类B，类B就是内部类。
3.2 内部的访问特点
A:内部类可以直接访问外部类的成员，包括私有。
B:外部类要访问内部类的成员，必须创建对象。
classOuter {private int num = 10;classInner {public voidshow() {
System.out.println(num);
}
}public voidmethod() {//找不到符号//show();
Inner i= newInner();
i.show();
}
}classInnerClassDemo {public static voidmain(String[] args) {
}
}
3.3 内部类位置
按照内部类在类中定义的位置不同，可以分为如下两种格式：
成员位置:在成员位置定义的类，被称为成员内部类。
局部位置:在局部位置定义的类，被称为局部内部类。
classOuter {private int num = 10;//成员位置
/*class Inner {
}*/
public voidmethod() {//局部位置
classInner {
}
}
}classInnerClassDemo2 {public static voidmain(String[] args) {
}
}
3.4 成员内部类
【如何直接访问内部类的成员】
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
classOuter {private int num = 10;classInner {public voidshow() {
System.out.println(num);
}
}
}classInnerClassDemo3 {public static voidmain(String[] args) {//需求：我要访问Inner类的show()方法//格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
Outer.Inner oi = new Outer().newInner();
oi.show();
}
}
【成员内部类的修饰符】
private：为了保证数据的安全性
/*案例：我有一个人(人有身体，身体内有心脏。)*/
classBody {private classHeart {public voidoperator() {
System.out.println("心脏搭桥");
}
}public voidmethod() {if(如果你是外科医生) {
Heart h= newHeart();
h.operator();
}
}
}classBodyDemo{public static voidmain(String[] args) {//按照我们刚才的讲解，来使用一下
Body.Heart bh = new Body().newHeart();
bh.operator();//加了private后，就不能被访问了，那么，怎么玩呢?
Body b = newBody();
b.method();
}
}
static：为了方便访问数据
成员内部类被静态修饰后的访问方式是：外部类名.内部类名 对象名 = new 外部类名.内部类名();
classOuter {private int num = 10;//注意：静态内部类访问的外部类数据必须用静态修饰。
private static int num2 = 100;//内部类用静态修饰是因为内部类可以看出是外部类的成员
public static classInner {public voidshow() {//错误: 无法从静态上下文中引用非静态变量 num//System.out.println(num);
System.out.println(num2);
}public static voidshow2() {//错误: 无法从静态上下文中引用非静态变量 num//System.out.println(num);
System.out.println(num2);
}
}
}classInnerClassDemo4 {public static voidmain(String[] args) {//使用内部类//错误:限定的新静态类//new Outer()是一个对象，Inner是静态成员，类用static修饰后，是不能通过外部的对象访问的//Outer.Inner oi = new Outer().new Inner();//oi.show();//oi.show2();//成员内部类被静态修饰后的访问方式是://格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
Outer.Inner oi = newOuter.Inner();
oi.show();
oi.show2();//show2()的另一种调用方式
Outer.Inner.show2();
}
}
【成员内部类练习】
补齐程序(注意:内部类和外部类没有继承关系)
classOuter {public int num = 10;classInner {public int num = 20;public voidshow() {int num = 30;
System.out.println(?);
System.out.println(??);
System.out.println(???);
}
}
}
要求请填空，在控制台分别输出30，20，10。
classOuter {public int num = 10;classInner {public int num = 20;public voidshow() {int num = 30;
System.out.println(num);//30
System.out.println(this.num);//20//System.out.println(new Outer().num);//10
System.out.println(Outer.this.num);//10
}
}
}classInnerClassTest {public static voidmain(String[] args) {
Outer.Inner oi= new Outer().newInner();
oi.show();
}
}
3.5 局部内部类
A：可以直接访问外部类的成员
B：在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
classOuter {private int num = 10;public voidmethod() {//int num2 = 20;
final int num2 = 20;classInner {public voidshow() {
System.out.println(num);//从内部类中访问本地变量num2; 需要被声明为最终类型
System.out.println(num2);//20
}
}
Inner i= newInner();
i.show();
}
}classInnerClassDemo5 {public static voidmain(String[] args) {
Outer o= newOuter();
o.method();
}
}
注意：局部内部类访问局部变量必须用final修饰！为什么呢？
因为局部变量是随着方法的调用而调用，随着方法的调用完毕而消失。这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。
3.6 匿名内部类
匿名内部类，就是内部类的简化写法。
【前提】
存在一个类或者接口(这里的类可以是具体类也可以是抽象类)
【格式】
new类名或者接口名(){
重写方法;
}
【本质】
匿名内部类的本质是，是一个继承了该类或者实现了该接口的子类匿名对象。
interfaceInter {public abstract voidshow();public abstract voidshow2();
}classOuter {public voidmethod() {//一个方法的时候
/*new Inter() {
public void show() {
System.out.println("show");
}
}.show();*/
//二个方法的时候
/*new Inter() {
public void show() {
System.out.println("show");
}
public void show2() {
System.out.println("show2");
}
}.show();
new Inter() {
public void show() {
System.out.println("show");
}
public void show2() {
System.out.println("show2");
}
}.show2();*/
//如果我是很多个方法，就很麻烦了//那么，我们有没有改进的方案呢?
Inter i = new Inter() { //多态
public voidshow() {
System.out.println("show");
}public voidshow2() {
System.out.println("show2");
}
};
i.show();
i.show2();
}
}classInnerClassDemo6 {public static voidmain(String[] args) {
Outer o= newOuter();
o.method();
}
}
【匿名内部类在开发中的使用】
首先回顾我们曾经讲过的方法的形式参数是引用类型的情况，重点是接口的情况，我们知道这里需要一个子类对象。而匿名内部类就是一个子类匿名对象，所以，可以使用匿名内部类改进以前的做法。
interfacePerson {public abstract voidstudy();
}classPersonDemo {//接口名作为形式参数//其实这里需要的不是接口，而是该接口的实现类的对象
public voidmethod(Person p) {
p.study();
}
}//实现类
class Student implementsPerson {public voidstudy() {
System.out.println("好好学习,天天向上");
}
}classInnerClassTest2 {public static voidmain(String[] args) {//测试
PersonDemo pd = newPersonDemo();
Person p= newStudent();
pd.method(p);
System.out.println("--------------------");//匿名内部类在开发中的使用//匿名内部类的本质是继承类或者实现了接口的子类匿名对象
pd.method(newPerson(){public voidstudy() {
System.out.println("好好学习,天天向上");
}
});
}
}
【补充练习】
按照要求，补齐代码
interfaceInter {voidshow();
}classOuter {//补齐代码
}classOuterDemo {public static voidmain(String[] args) {
Outer.method().show();
}
}
要求在控制台输出”HelloWorld”
interfaceInter {voidshow();//public abstract
}classOuter {//补齐代码
public staticInter method() {//子类对象 -- 子类匿名对象
return newInter() {public voidshow() {
System.out.println("HelloWorld");
}
};
}
}classOuterDemo {public static voidmain(String[] args) {
Outer.method().show();/*1:Outer.method()可以看出method()应该是Outer中的一个静态方法。
2:Outer.method().show()可以看出method()方法的返回值是一个对象。
又由于接口Inter中有一个show()方法,所以我认为method()方法的返回值类型是一个接口。*/}
}
278
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
