面向对象下-3

系统管理员 2022-07-29 10:46 138阅读 0赞

**面向对象下-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");

\};

发表评论取消回复

表情：

评论列表（有 0 条评论，138人围观）

面向对象下-3

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Java面向对象3

相关 Java面向对象（下）

相关 java--面向对象3

相关面向对象下-3

相关面向对象下-2

相关面向对象下-1

相关 Java面向对象3

相关 1.3 面向对象

相关 Python3: 面向对象

相关 Java 面向对象（3）