面向对象下-3
1.package关键字的概述及作用
* A:为什么要有包
*将字节码(.class)进行分类存放
*包其实就是文件夹
2.包的定义及注意事项
* A:定义包的格式
*package 包名;
*多级包 用.分开即可
* B:定义包的注意事项
*A:package语句必须是程序的第一条可执行的代码
*B:package语句在一个java文件中只能有一个
*C:如果没有package，默认表示无包名
3.带包的类编译和运行
* A:如何编译运行带包的类
*a:javac编译的时候带上-d即可
*javac -d . HelloWorld.java //.代表当前路径
*b:通过java命令执行。
*java 包名.HellWord(类名)
4.不同包下类之间的访问
* A:案例演示
*不同包下类之间的访问
在A包的类中使用B包的类创建对象时, 要用 B的包名.类名 对象名= new B的包名.类名()
前提B中所有类和方法是公共的(public)
5.import关键字的概述和使用
* A:为什么要有import
* 其实就是让有包的类对调用者可见,不用写全类名了 ,即类名 对象名= new 类名()
* B:导包格式
*import 包名;
*注意：* 这种方式导入是到类的名称。
* 虽然可以最后写*，但是不建议。 //*代表通配符,他会到该包下挨个匹配,匹配上就导入
* C:package,import,class有没有顺序关系(面试题)
有.1 2 3
6.四种权限修饰符的测试
* A:四种权限修饰符
*
本类 同一个包下(子类和无关类) 不同包下(子类) 不同包下(无关类)
private Y
默认 Y Y
protected Y Y Y
public Y Y Y Y
*Y代表可以访问
7.类及其组成所使用的常见修饰符
* A:修饰符：
*权限修饰符：private，默认的，protected，public
*状态修饰符：static，final
*抽象修饰符：abstract
* B:类：
*权限修饰符：默认修饰符，public //类不能用private,protected修饰
*状态修饰符：final //static修饰的是方法(可以修饰内部类),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
8.内部类概述和访问特点(
* A:内部类概述
在类中定义类
* B:内部类访问特点
*a:内部类可以直接访问外部类的成员，包括私有。
*b:外部类要访问内部类的成员，必须创建对象。
*外部类名.内部类名对象名 = 外部类对象.内部类对象;
* C:案例演示
*内部类极其访问特点
class Outer {
privateint num = 10;
classInner {
publicvoid method() {
System.out.println(num); // a, 可以直接访问外部类的成员 ,输出10
System.out.println("helloworld");
}
}
}
class Demo1_InnerClass {
publicstatic void main(String[] args) {
//Inneri = new Inner();
//i.method();
//外部类名.内部类名 = 外部类对象.内部类对象
Outer.Inneroi = new Outer().new Inner(); //创建内部类对象
oi.method(); //调用内部类方法
}
}
9.成员内部类私有使用
* private
class Demo2_InnerClass {
publicstatic void main(String[] args) {
//Outer.Inneroi = new Outer().new Inner();
//oi.method();
Outero = new Outer();
o.print();
}
}
class Outer {
privateint num = 10;
privateclass Inner {
publicvoid method() {
System.out.println(num);
}
}
publicvoid print() { //内部类私有,只能创建一个公共的对外访问
Inneri = new Inner();
i.method();
}
}
10.静态成员内部类
* static
* B:成员内部类被静态修饰后的访问方式是:
*外部类名.内部类名对象名 = 外部类名.内部类对象;
class Demo1_InnerClass {
publicstatic void main(String[] args) {
//外部类名.内部类名 对象名 = 外部类名.内部类对象;
Outer.Inneroi = new Outer.Inner(); //右边相当于Outer.new Inner();
oi.method(); //针对inner1的访问方式
Outer.Inner2.print(); //针对inner2的访问方式
}
}
class Outer {
staticclass Inner {
publicvoid method() {
System.out.println("method"); //静态内部类中包含非静态的方法
}
}
staticclass Inner2 {
publicstatic void print() {
System.out.println("print"); //静态 内部类中包含静态的方法
}
}
}
11.成员内部类的习题练习
* A:习题
*要求：使用已知的变量，在控制台输出30，20，10。
//内部类之所以能获取到外部类的成员,是因为他能获取到外部类的引用外部类名.this
classOuter {
publicint num = 10;
classInner {
publicint num = 20;
publicvoid show() {
intnum = 30;
System.out.println(?); //num, 就近原则
System.out.println(??); //this.num
System.out.println(???); //outer.this.num ,拿到了Outer下的成员变量
}
}
}
classInnerClassTest {
publicstatic void main(String[] args) {
Outer.Inneroi = new Outer().new Inner();
oi.show();
}
}
12.局部内部类访问局部变量的问题
* A:案例演示
class Demo1_InnerClass {
publicstatic void main(String[] args) {
Outero = new Outer();
o.method();
}
}
//局部内部类
class Outer {
publicvoid method() {
finalint num = 10; //注意!!!
classInner {
publicvoid print() {
System.out.println(num);
}
}
Inneri = new Inner(); //注意!!!
i.print();
}
/*publicvoid run() {
Inneri = new Inner(); //局部内部类,只能在其所在的方法中访问,写上该方法会报错!!!
i.print();
}*/
}
*在外部类的方法中在定义一个内部类,局部内部类,只能在其所在的方法中访问
*局部内部类访问局部变量必须用final修饰
*局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用, 但是jdk1.8取消了这个事情(可以不加final),所以我认为这是个bug
13.匿名内部类的格式和理解
* A:匿名内部类
//匿名内部类要写在方法里
*就是内部类的简化写法。
* B:前提：存在一个类或者接口
*这里的类可以是具体类也可以是抽象类。
* C:格式：
new 类名或者接口名(){ //new 类名{}代表继承这个类,new 接口名(){}代表实现这个接口
重写方法;
}
* D:本质是什么呢?
*是一个继承了该类或者实现了该接口的子类匿名对象。
* E:案例演示,按照要求来一个匿名内部类:
class Demo1_NoNameInnerClass {
publicstatic void main(String[] args) {
Outero = new Outer();
o.method();
}
}
interface Inter {
publicvoid print();
}
class Outer {
classInner implements Inter {
publicvoid print() {
System.out.println("print"); //这块加上method方法中被注释掉的前两行,这是有名字的内部类
} }
publicvoid method(){ //下面是匿名内部类!!!
//Inneri = new Inner(); //父类引用指向子类对象
//i.print();
[ new Inter() { //实现Inter接口
publicvoid print() { //重写抽象方法
System.out.println("print");
}
}] .print(); //[]中整个代表inter的子类对象!!!,然后 . 调用它里面的print方法
} }
14.匿名内部类重写多个方法调用
* A:案例演示,匿名内部类的方法调用
class Demo2_NoNameInnerClass {
publicstatic void main(String[] args) {
Outero = new Outer();
o.method();
} }
interface Inter {
publicvoid show1();
publicvoid show2();
}
class Outer {
publicvoid method() {
/*newInter(){
publicvoid show1() {
System.out.println("show1");
}
publicvoid show2() {
System.out.println("show2");
}
}.show1();
newInter(){
publicvoid show1() {
System.out.println("show1");
}
publicvoid show2() {
System.out.println("show2"); //麻烦!!!
}
}.show2();*/
--------------------------------------------------------------------------------------------
Interi = new Inter(){ //父类引用指向子类对象 ,但不能使用子类特有的法!!!
publicvoid show1() {
System.out.println("show1");
}
publicvoid show2() {
System.out.println("show2");
}
/*publicvoid show3() {
System.out.println("show3");
}*/
};
i.show1();
i.show2();
//i.show3(); // 出错,匿名内部类是不能向下转型的,因为没有子类类名(因为是匿名的,没有名字),父类不能调用子类的方法!!!!
} }
15.匿名内部类在开发中的应用
* A:代码如下
*
//这里写抽象类，接口都行
abstractclass Person {
publicabstract void show();
}
classPersonDemo {
publicvoid method(Person p) {
p.show();
}
}
classPersonTest {
publicstatic void main(String[] args) {
//如何调用PersonDemo中的method方法呢?
PersonDemopd = new PersonDemo ();
}
}
1.用有名字的类:可以新建一个学生类去继承person类,然后重写里面的show()方法,接着pd.method(newstudent()) //这相当于父类引用指向子类对象
2.用匿名类:
pd.method(new Person() { //继承了person抽象类,并重写了里面的方法
publicvoid show() {
System.out.println("show");
}
}); //将匿名类当做参数去传递
*注:附源码如下:classTest1_NoNameInnerClass {
publicstatic void main(String[] args) {
//如何调用PersonDemo中的method方法呢?
PersonDemopd = new PersonDemo ();
//pd.method(newStudent());
pd.method(newPerson() {
publicvoid show() {
System.out.println("show");
}
});
}
}
//这里写抽象类，接口都行
abstract class Person {
publicabstract void show();
}
class PersonDemo {
publicvoid method(Person p) {
p.show();
}
}
class Student extends Person {
publicvoid show() {
System.out.println("show");
}
}
16.匿名内部类的习题练习
* A:习题
按照要求，补齐代码
interfaceInter { void show(); }
classOuter { //补齐代码 }
classOuterDemo {
publicstatic void main(String[] args) {
Outer.method().show();
}
}
要求在控制台输出”HelloWorld”
class Test2_NoNameInnerClass {
publicstatic void main(String[] args) {
//Outer.method().show(); //链式编程,每次调用方法后还能继续调用方法,证明调用方法返回的是对象
Interi = Outer.method();
i.show();
}
}
//按照要求，补齐代码
interface Inter {
voidshow();
}
class Outer {
//补齐代码
publicstatic Inter method() {
returnnew Inter() {
publicvoid show() {
System.out.println("show");
}
};
}
}
1115
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
