1:形式参数和返回值的问题

         (1)形式参数;

                   类名:需要该类的对象

                   抽象类名:需要该类的子类对象

                   接名:需要该接口的实现类对象

         (2)返回值类型

                   类名:返回的是该类的对象

                   抽象类名:返回的是该类的子类对象

                   接口名:返回的是该接的实现类的对象

         (3)链式编程

                   对象。方法1().方法2()…….方法n();

                   这种用法:其实在方法1()调用完毕后,应该一个对象

                            方法2()调用完毕后,应该返回一个对象

                            方法n()调用完毕后,可能是对象,也可以不是对象

 

         2:包(理解)

                   (1)其实就是文件来

                   (2)作用:

                            A:区分同名的类

                            B:对类进行分类管理

                                     a:按照功能分

                                     b:按照模块分

         (3)包的定义(掌握)

                   package包名;

                   多级包用,分开

         (4)注意事项:(掌握)

                   A: packag语氖必须在文件中的第一条有效

                   B:在一个aa文件中,只能有一个 package

                   C:如果没有 packag,默认就是无包名

         (5)带包的编译和运行

                   A:手动式

                   B:自动式(掌握)

                   javac -d. Helloworld. java

         3:导包(掌握)

                   (1)我们多次使用一个带包的类,非常的麻烦,这个时候,Java就提供了一个关键字 import

                   (2)格式:

                            import包名…类名;

                            import包名…*;(不建议)

         (3) package, import,c1ass的顺序

                   package > import > class

 

 

         4:权限修饰符(掌握)

                   (1)权限修饰符

                                     本类         同一个包下     不同包下的子类     不同包下的无关类

                   private               Y

                   默认                   Y       Y

                   protected         Y       Y                Y

                   public                 Y       T                Y                Y

 

                   (2)这四种权限修饰符在任意肘刻只能出现一犭

                            public class Demo{}

         5:常见的修饰符(理解)

                   (1)分类

                            权限修饰符; private,默认, protected, pub1ic

                            状态絛饰符: static,fina1

                            抽象修饰符: abstract

                   (2)常见的类及其组成的修饰

                            类:

                                     默认, public, final, abstract

                                     常用的: public

                            成员变量

                                     private, 默认, protected, public, static, final

                                     常用的: private

                            构造方法

                                     private,默认, protected, public

                                     常用的:pub1ic

                            构造方法

                                     private,默认, protected,pub1ic

                                     常用的;pub1ic

                            成员方法:

                                     private,默认, protected, public, static, final, abstract

                                     常用的;pub1ic

                   (3)另外比较常见的:

                            public static final int X=10;

                            public static void show(){}

                            public final void show(){}

                            public abstract void show();

         6:内部类(理解

                   (1)把类定义在另一个类的内部,该类就被称为内部类

                            举例:把类B定义在类A中,类B就被称为内部类

                   (2)内部类的访问规则

                            A:可以直接访问外部类的成员,包括私有

                            B:外部类要想访问内部类成员,必须创建对象

                   (3)内部类的分类

                            A:成员内部类

                            B:局部内部类

                   (4)成员内部类

                            A: private为了数据的安全性

                            B: static为了访问的方便性

 

                            成员内部类不是静态的:

                            外部类名.内部类名对象名=new 外部类名.new 内部类名()

                            成员内部类是静态的:

                            外部类名.内部类名对象名=new 外部类名.内部类名()

                   (5)成员内部类的面试题(看程序写结果)

                            30,20,10

                            class Outer {

                                     public int num=10;

 

                                     class Inner{

                                               public int num =20;

 

                                               public viod show(){

                                                        int num = 30;

                                                        System. out. println(num);

                                                        System. out. println(this.num);

                                                        System. out. println(Outer.this.num);

                                               }

                                     }

                            }

 

 

 

                   (6)局部内部类

                            A:局部内部类访问局部变量必须加fina1修饰

                            B:为什么呢?

                                     因为局部变量使用完毕就消朱,而堆内存的数据并不会立即道失

                                     所以,堆内存还是用该变量,而改变量已经没有了

                                     为了让该值还存在,就加fina1修饰

                                     通过反編译工具我们看到了,加入final后,堆内存直接存储的是值,而不是变量名

                   (7)盾名内部类(掌握)

                            A:是局部内部类的简化形式

                            B:前提

                                     存在一个类或者接口

                            C:格式

                                     new类名或者接口名(){

                                               重写方法;

                                     }

                            D:本质

                                     其实是继承该类或者实现接口的子类匿名对象

                   (8)匿名内部类在开发中的使用

                            我们在开发的时候,会看到抽象类,或者接作为参数

                            而这个时候,我们知道实际要的是一个子类对象

                            如果该方法仅仅调用一次,我们就可以使用名内部类的格式简化。

版权声明:本文为zhangchengbing原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://www.cnblogs.com/zhangchengbing/p/8276470.html