Java基础知识

一、

1、数据类型分类：

A:基本数据类型：4类8种

整数       占用字节数

       byte               1          byte的范围是：-128到127。如果超过127，就是最小值-128.

       short              2    

       int                4

       long               8

浮点数

       float               4

       double            8

字符

       char               2          可以存储一个汉字，Java语言里的字符占用两个字节，Java用的是Unicode编码。

布尔

       boolean          1

B:引用数据类型：类，接口，数组。

2、数据类型转换(掌握)

       (1)boolean类型不参与转换

       (2)默认转换

              A:从小到大

              B:byte,short,char -- int -- long -- float（long,float的底层的存储结构不同，float在计算机中用四个字节存储，float表示的数据范围比long大）-- double

              C:byte,short,char之间不相互转换，直接转成int类型参与运算。

       (3)强制转换

              A:从大到小

              B:可能会有精度的损失，一般不建议这样使用。

              C:格式：目标数据类型变量名 = (目标数据类型) (被转换的数据);

3、Java里面不支持全局变量。

二、

1、运算符：链接常量和变量，对常量和变量进行操作

   运算：操作

   整数相除只能得到整数，要想得到小数，把其中一个数转换为小数类型。

2、++、--

   常量不可++、--

   单独使用，放在操作数前面、后面，效果一样。

   放在操作数的前面，先自增或自减，然后再参与运算。放在操作数后面，先参与运算，再自增或自减

3、扩展的赋值运算符其实隐含了一个强制类型转换。

 

 面试题：  short s=1；s=s+1；（没有转换类型，会损失精度）不同于short s=1；s+=1；s+=1等价于s=（s的数据类型）（s+1）；

4、比较运算符：==，！=，>,>=,<,<=

       无论操作简单还是复杂，结果返回boolean型值。

5、逻辑运算符

 

笔试题：&  &&  |  ||区别：

       &  逻辑与，有false则false

       &&有短路的作用，左边是false，右边不执行。

  &和&&最终结果一样。

       |  逻辑或，有true则true

       ||有短路的作用，左边是true，右边不执行。

       !逻辑非，非false则true，非true则false。

       ^  逻辑异或，相同为false，不同为true。

   逻辑运算一般用于连接Boolean类型的表达式或者值。

6、位运算

  &  有0则0

  |  有1则1

  ^  相同则0，不同则1。一个数据对另一个数据位异或两次，该数本身不变。

  ~   按位取反。0变1,1变0（补码、反码、原码）

   （1）因为是位运算，所以先转换成二进制。

  <<  左移 左边最高位丢弃，空位补0   左移把左边的数据*2的移动次幂

  >>  右移 最高位是0，左边补0；最高位是1，左边补1   右移把左边的数据/2的移动次幂

  >>>  无符号右移  无论最高位是0还是1，左边补齐0

 

面试题：  两个整数变量的交换：

 （1）使用第三方变量

 （2）用位异或实现：

          a=a^b;

          b=a^b;(a^b^b=a)

          a=a^b;(a^b^a=b)

 （3）变量相加的做法

          a=a+b;

          b=a-b;

          a=a-b;

 （4） b=(a+b)-(a=b)

 

面试题：请用最有效率的方式写出计算2*8的结果

       2<<3

7、三目运算符

       格式：比较表达式？表达式1：表达式2

       执行流程：根据表达式比较的计算返回一个true或者false，若true，表达式1作为结果，若false，表达式2作为结果。

8、如何实现键盘录入数据

       A、导包：import java.util.Scanner;

       B、创建键盘录入对象：Scanner sc = newScanner(System.in)

       C、通过对象获取数据：int x = sc.nextInt();

       D、String 是= sc.nextLine()；获取字符串

四、流程控制语句

1、顺序结构：从上往下以此执行。

2、选择结构：按照不同的选择执行不同的代码。

       if语句：比较表达式结果是boolean类型

       if语句与三元运算符区别：三元简单。三元都可以用if实现，反之不成立。当if语句控制的操作是一个输出语句的时候就不能用三元实现，三元运算符操作完毕就应该有一个结果，而不是输出。。

       switch语句：switch（表达式）{case值1：语句体1；break；case值2：语句体2；break；…default：语句体n+1；（break；）程序最后一个break可以省略。}

case后只能是常量，不能是变量。Case后面不能出现相同值。Default可以省略，但是省略后就没有校验，他是对不正确情况作出提示。

 

面试题：      switch表达式地方的值是有限定的。Byte、short、int、char；在JDK5以后可以是枚举；在JDK7以后可以是字符串。所以，byte、long（不可以）、String可以作为switch的表达式。

3、循环结构

       for、while、（while（判断条件语句）{循环体语句；控制条件语句；}）

       do…while循环格式：do{循环体语句；控制条件语句；}while（判断语句）；先循环，后判断

区别：如果想在循环结束后继续使用控制条件的那个变量，使用while循环，否则使用for循环，因为变量及早的从内存中消失，可以提高内存使用效率。

       如果不明确要做多少次循环，用while合适，如果明确，用for。

       do…while循环至少执行一次循环体，而for，while循环先判断是否成立，然后决定是否执行循环体。

注意：死循环：A：控制条件语句控制的那个变量的问题，不要丢了。

                       B：两种最简单的死循环格式：while（true）{}

                                                                       for（；；）{}

          嵌套循环：外循环控制行数；内循环控制列数。

       ‘\t’tab键    ‘\r’回车     ‘\n’换行

4、跳转控制语句

goto在Java中是保留字不能使用，所以有

break：中断；switch语句中；循环语句中加入if判断时使用；效果：跳出单层循环；跳出多层循环；想要跳出多层循环，给循环起个名字（带标签的语句），break 循环名；

continue：继续；在循环语句中；

区别：break与continue区别：break是跳出循环，continue是跳出一次循环，进入下一次的执行。

return：返回；不是为了跳出循环体，常用结束一个方法。退出一个方法，跳转到上一个方法的调用。

 

五、方法和数组

1、方法：完成特定功能的代码块，在很多语言里面有函数的定义。

 方法的执行特点：方法不调用不运行。

调用方法：在main方法中调用     方法名（参数）；

有明确返回值调用：A、单独调用（没意义）

  B、输出调用system.out.print(方法名（参数）)；

  C、赋值调用int result=方法名（参数）；

输出system.out.print（result）；

方法注意事项：方法与方法是平级关系，不能嵌套定义。方法定义时候，参数用逗号隔开。方法调用时不用再传递数据类型。如果方法有明确返回值，一定要return带回一个值。

没有明确返回值：void类型方法定义调用：

A：单独调用（没问题，只有这一种调用）

B：输出调用（报错）

C：赋值调用（报错）

2、方法重载

方法功能相同，参数列表不同，Java允许起同样的方法名。根据传参的个数不同或者参数类型不同，虚拟机（JVM）自动识别。与返回值类型无关。

3、数组

存储多个变量的容器。变量类型一致。

4、Java中的内存分配

栈：存放的是局部变量（在方法定义中或方法声明上的变量）。栈内存的数据用完         就释放。

栈内存的两个引用指向同一个内存空间，无论是他们谁的操作，都是针对同一       个地方

堆：存放的是所有new出来的东西。

堆内存特点：A：每一个new出来的东西都有地址值。

B：每个变量都有默认值。

C：使用完就变成垃圾，不会立即回收，会在垃圾回收器空闲的        时候回收。

方法区：（面向对象部分详细讲解）

本地方法区（和系统相关）

寄存器（给CPU用）

5、数组的静态初始化

数据类型[] 数组名 = new 数据类型[] {元素1，元素2....}

简化：数据类型[] 数组名 = {元素1，元素2....}；

   动态数组初始化只给长度，系统给出默认值。

6、数组操作常见的问题

数组索引越界异常（原因：访问了不存在的索引）；空指针异常（原因：数组已经不再指向堆内存，而你  还用数组名去访问元素）；

数组遍历：for(int x =0;x<arr.length;x++){System.out.println(arr[x]);}

数组获取最值：找个参照物，遍历，大（小）的留下来，小（大）的离开。

数组逆序：A：for(int x=0;x<arr.length/2;x++)

       {    int temp = arr[x];

            arr[x] =arr[arr.length-1-x];

            arr[arr.length-1-x= temp];     }

                    然后遍历数组；

B：for(intstart=0;end=x.length-1;stard<=end;start++;end--)

{   int temp = arr[start];

    arr[start] = arr[end];

arr[end] = temp;   }

 然后遍历数组；

数组查表法：（根据键盘录入，查找星期）

数组元素查找：（查找指定元素第一次在数组中出现的索引）

for(int x=0;x<arr.length;x++)

{   if(arr[x] == value)

{     index = x;

break;     }     }

注意：只要是判断，就可能是false，所以要有return -1；语句。

六、二维数组：元素是一维数组

1、二维数组

动态初始化：

数据类型[] [] 数组名 = new 数据类型[m][n]   列固定

数据类型[] [] 数组名 = new 数据类型[m][n]   列不固定

注意：int[] x,y[];x是一维数组；y是二维数组；二维数组第一个中括号里的值必须给出，第二个值可给可不给（内存没法分配）。

静态初始化：

数据类型[] [] 数组名 = new 数据类型[][]{{元素1，元素2，...}，{元素1，元素2，...},...}

数据类型[] [] 数组名 = {{元素1，元素2，...}，{元素1，元素2，...},...}

数组遍历：for(intx=o;x<arr.length;x++){

//外循环控制的是二维数组的长度，其实就是一维数组的个数；

for(int y=0;y<arr[x].length;y++){

//内循环控制的是一维数组的长度

system.out.println{arr[x][y]+””}}}

注意：Java中的参数传递问题：基本类型传递的是基本数据值，形式参数的改变对实际参数没有影响；引用类型传递的是地址值，形式参数的改变直接影响实际参数；

数据加密问题：把一组数(字符串)转换成数组形式：列如：12345转换成                                            arr[]={5,4,3,2,1}

int number=12345;

int index = 0;

while(number>0){

arr[index] = number%10;

index++;

number=number/10;}//转换之后数据已经倒序；

//把数组的元素拼接成一个字符串返回：

String s = “”;//定义一个空内容字符串；

for(int x=0;x<index;x++){

s+=arr[x];}

returns;

七、面向对象

1、面向对象思想：是基于面向过程的编程思想。

面向过程：强调的是每一个功能的步骤

面向对象：强调的是对象，然后由对象去调用功能。

面向对象特点：A：是一种更符合我们思想习惯的思想；

  B：可以将复杂的事情简单化；

  C：将我们从执行者变成了指挥者；

面向对象开发、设计、特征

A、开发：不断的创建对象，使用对象，指挥对象做事情。

B、设计：管理和维护对象之间的关系，

C、特征：封装、继承、多态。

类：是一组相关的属性和行为的集合。是一个抽象的概念。

对象：是该事物的具体表现形式。具体存在的个体。

变量：成员变量；局部变量区别：

A:在类中的位置不同

            成员变量：在类中方法外

            局部变量：在方法定义中或者方法声明上

B:在内存中的位置不同

            成员变量：在堆内存

            局部变量：在栈内存

C:生命周期不同

            成员变量：随着对象的创建而存在，随着对象的消失而消失

            局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

 

D:初始化值不同

            成员变量：有默认初始化值

            局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

           

        注意事项：

            局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

形式参数问题：

基本类型：形式参数的改变不影响实际参数

        引用类型：形式参数的改变直接影响实际参数

如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。

匿名对象：就是没有名字的对象。

        匿名对象的应用场景：

        A:调用方法，仅仅只调用一次的时候。

            注意：调用多次的时候，不适合。

            那么，这种匿名调用有什么好处吗?

                有，匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。

        B:匿名对象可以作为实际参数传递

2、封装：

隐藏对象的属性和实现细节，对外提供公共访问方式。

A：好处：隐藏实现细节，提供公共的访问方式

提高代码的复用性

        提高安全性

B：原则：将不需要对外提供的内容都隐藏起来

把属性隐藏，提供公共方法对其访问

关键字：private

可以修饰成员变量和成员方法。

被修饰的成员只能在本类中被访问。

封装和private常见应用：把成员变量用private修饰，提供对应的getXxx(),setXxx()方法；

This:

代表当前类的对象引用，方法被哪个类引用， 就代表当前类的一个对象。

解决局部变量隐藏成员变量

3、构造方法 construct

给对象的数据进行初始化

格式：A：方法名和类名相同

  B：没有返回值类型，连void都没有

  C：没有具体返回值

构造方法中可以有return语句，return;

在任何void类型的方法的最后都可以写上return；

注意事项：A：如果我们没有给出构造方法，系统将会自动提供一个无参构造方法

  B：如果我们给出了构造方法(不管是有参无参)，系统将不再提供默认     的无参构造。

给成员变量赋值有两种方式：

A：SetXxx()

B:带参构造方法

输出成员变量值的方法：

A：通过getXxx()分别获取然后拼接

B：通过调用show()方法搞定

4、类的组成：成员变量、构造方法、成员方法

A、调用无参返回值方法

S.show（）；

B、调用无参有返回值方法

String result =s.getString();

System.out.println(result);

C、调用带参无返回值方法

s.method(“”);

D、调用带参带返回值方法

String result2 =s.function(“hello”,”world”);

System.out.println(result2);

5、面向对象创建对象

Stusent s = new Student();

A、 把Student.class文件加载到内存

B、 在栈内存给s变量开辟一个空间

C、 在堆内存为学生对象申请一个空间

D、 给成员变量进行默认初始化

E、 给成员变量进行显示初始化

F、 通过构造方法给成员变量进行初始化

G、 初始化完毕，把堆内存的地址值赋值给栈内存的s变量

变量是用来描述这个类信息的时候，定义为成员变量。

变量的范围越小越好，因为能及时被回收。

关键字：static

    静态修饰数据被所有对象共享。

特点：A、随着类的加载而加载。

B、优先于对象存在。

C、被类的所有对象共享。

D、可以通过类名调用。（也可以通过对象名调用）

静态修饰的内容一般我们称其为：与类相关的，类成员

静态方法中没有this

    静态是随着类的加载而加载，this是随着对象的创建而存在，静态比对象先存在。

    静态方法只能访问静态的成员变量和静态的成员方法。

静态变量和成员变量的区别

        A:所属不同

            静态变量：属于类，类变量

            成员变量：属于对象，对象变量，实例变量

        B:内存位置不同

            静态变量：方法区的静态区

            成员变量：堆内存

        C:生命周期不同

            静态变量：静态变量是随着类的加载而加载，随着类的消失而消失

            成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失

        D:调用不同

            静态变量：可以通过对象名调用，也可以通过类名调用

            成员变量：只能通过对象名调用

main方法是静态的

        public:权限最大

        static:不用创建对象调用

        void:返回值给jvm没有意义

        main:就是一个常见的名称。

        String[]args:可以接收数据，提供程序的灵活性

            格式：java MainDemo hello world java

                  java MainDemo 10 20 30

八、 

1、代码块：用{}括起来的部分

2、分类：

局部代码块：局部位置，限定变量生命周期

构造代码块：在类中的成员位置，用大括号括起来，每次调用构造方法执行前，都会先执行构造代码块。

作用：可以把多个构造方法中的共同代码放一起

静态代码块：在类中的成员位置，用static修饰

作用：一般对类进行初始化

面试题：静态代码块，构造代码块，构造方法的执行顺序

静态代码块--构造代码块--构造方法

静态代码块：只执行一次

构造代码块每次调用构造方法都执行

3、继承

好处：提高代码复用性

提高代码的维护性

让类与类之间产生关系，是多态前提（也是继承弊端）

弊端：让类与类之间产生关系，类的耦合性增强。

要低耦合，高内聚。

打破了封装性

Java中继承的特点：

A：支持单继承，不支持多继承。

B：支持多层继承。

Java中继承注意事项

A：子类只能继承父类所有非私有的成员（成员方法和成员变量）

B：子类不能继承父类的构造方法，但可以通过super关键字去访问父类构造方法

C：不要为了部分功能而去继承。

4、This和super区别：

This代表本类对象的引用

Super代表父类存储空间的标志（可以理解为父类引用，可以操作父类成员变量）

A：调用成员变量

this.成员变量 调用本类的成员变量

super.成员变量 调用父类的成员变量

B:调用构造方法

this(...)   调用本类的构造方法

super(...)  调用父类的构造方法

C:调用成员方法

this.成员方法 调用本类的成员方法

super.成员方法 调用父类的成员方法

5、继承中成员变量的关系：

A：子类成员变量和父类成员变量名称不一样

B：子类成员变量和父类成员变量名称一样，采用就近原则。先在子类方法的局部 范围找，有就用；然后在子类成员范围找，有就用；在父类的局部范围找，有就使  用；如果都没有，就报错。

 继承中构造方法关系：

            A:子类的构造方法默认会去访问父类的无参构造方法

                是为了子类访问父类数据的初始化

注意：每一个构造方法的第一条语句默认是super（）；

            B:父类中如果没有无参构造方法

a:在父类中加一个无参构造

                    b:子类通过super去明确调用父类带参构造方法

子类中一定要有你一个访问了父类的构造方法，否则父类数据就没有    初始化。

c：子类通过this调用本身的其他构造，但是一定会有一个去访问了    父类的构造，让父类提供无参构造

注意：super（）或者this（）一定要放在第一行,如果不是第一行，就 可能对父类数据进行了多次初始化。

面试题：

A：一个静态代码块，构造代码块，构造方法的执行流程

静态代码块>构造代码块>构造方法

B：静态的内容是随着类的加载而加载

静态代码块的内容会优先执行

C：子类初始化之前会进行父类的初始化

一个类的初始化过程：

成员变量初始化--默认初始化--显示初始化--构造方法初始化

子父类的初始化（分层初始化）

先进行父类初始化，然后进行子类初始化。

            虽然子类的构造方法默认有一个super（），初始化的时候不是按照那个顺序          进行的。而是按照分层初始化进行的，它仅仅表示要先初始化父类数据，再初          始化子类数据。

6、继承中成员方法的关系：

A：子类中的方法和父类中的方法声明不一样

B：子类中的方法和父类中的方法声明一样

通过子类调用方法：

a：先找子类中有没有这个方法 ，有就使用

b:再看父类中有没有这个方法，有就使用

c：如果没有就报错

7、方法重写：子类中出现了和父类中方法声明一模一样的方法。（方法覆盖、复写）

如果方法名不同，就调用对应的方法

如果方法名相同，最终使用的是子类自己的。

方法重写应用：当子类需要父类的功能，又定义了子类特有的内容。

方法重载：本类中出现的方法名一样，参数列表不同的方法，与返回值无关。

方法重写注意事项：

父类中的私有方法不能被重写。因为父类私有方法子类无法继承。

子类重写父类方法时，访问权限不能更低。（最好一致）

父类静态方法，子类必须通过静态访问。

面试题：

1：方法重写和方法重载的区别?方法重载能改变返回值类型吗?

方法重写：在子类中，出现和父类中一模一样的方法声明的现象。

方法重载：同一个类中，出现的方法名相同，参数列表不同的现象。

方法重载能改变返回值类型，因为它和返回值类型无关。

2：this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。

this:代表当前类的对象引用

super:代表父类存储空间的标识。(可以理解为父类的引用，通过这个东西可以访问父类的成员)

面试题：

A:一个类的初始化过程

            成员变量的初始化

                默认初始化

                显示初始化

                构造方法初始化

B:子父类的初始化(分层初始化)

            先进行父类初始化，然后进行子类初始化。

九、

1、final关键字

可以修饰类、方法、变量。

特点：修饰类：该类不能被继承。

修饰方法：被final修饰的方法不能被子类重写。

修饰变量：该变量不能被重新赋值。

常量：A：字面值常量：

B:自定义常量：final

面试题：final修饰局部变量的问题：

局部变量是基本数据类型：可以修饰局部变量，值不可改变。

局部变量是引用数据类型：地址值不能变，该对象堆内存的值可以变。

2、final修饰变量的初始化时机：

A：被final修饰的变量只能赋值一次

B：在构造方法完毕前（静态的常量）

3、多态：某一个事物在不同时刻表现出来的不同状态。

多态的前提：

A：要有继承关系或者实现关系。

B：要有方法重写，如果没有也是可以的，只是没有意义。

C：要有父类引用指向子类对象   父  f = new 子（）

4、多态中的成员访问特点：

A：成员变量

编译看左边，运行看左边。

B：构造方法

构造子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。

C：成员方法

编译看左边，运行看右边。

D：静态方法

编译看左边，运行看左边。（静态和类相关算不上重写，所以，访问还是左边）

由于

成员方法存在方法重写，所以它运行看右边。

5、多态好处：

A：提高代码的维护性（继承保证）

B：提高代码的扩展性。（有多态保证）

6、多态弊端

父不能使用子类特有功能。

如果想用子类方法：A：创建子类对象调方法（太占内存）。

B：把父的引用强制转换为子的引用（向下转型）

对象间的转型问题：

向上转型：从子到父  父类引用指向子类对象：Fu f = newZi();

向下转型：从父到子  父类引用转为子类对象：Zi z =(Zi)f;

ClassCastException ：类型转换异常。多态向下转型出现问题，不匹配。

多态的成员访问特点：

子类中有和父类中一样的方法叫重写；

子类中没有父类中出现过的方法，方法就被继承过来了。

7、抽象类：没有方法体的方法为抽象方法；类中有抽象方法，就是抽象类。

抽象类特点：

A：抽象类和抽象方法必须用abstract关键字修饰。

B：抽象类中不一定有抽象方法，但有抽象方法的类必须定义为抽象类

C：抽象类不能实例化，因为它不是具体的。抽象类有构造方法，但是不能实     例化。构造方法的作用是用于访问父类数据的初始化。

D：抽象的子类

a：如果不想重写抽象方法，孩子类是一个抽象类。

b：重写所有的抽象方法，这时候子类是一个具体的类。

抽象类的实例化是靠具体的子类实现的。是多态的方式。

Animal a = new Cat();

抽象类的成员特点：

成员变量：既可以是变量，也可以是常量。

构造方法：有。用于子类访问父类数据初始化。

成员方法：既可以是抽象的，也可以是非抽象的。

抽象类的成员方法特性：

A：抽象方法 强制要求子类做的事情。

B：非抽象方法 子类继承的事情，提高代码复用性。

抽象类面试问题：

一个类如果没有抽象方法，可以定义为抽象类吗？可以。意义：不让创建对象。

Abstract不能和哪些关键字共存：

Private   冲突。不能被重写

Final   冲突。不能被重写。

Static   无意义。

8、接口：额外扩展的功能

接口特点：

A：接口用关键字interface表示      interface 接口名{}

B：实现接口用implements表示       class 类名 implements 接口名{}

C:接口按照多态的方式实例化。

D：接口的子类：

A:可以是抽象类，但意义不大。

B：可以是具体类。要重写接口中的所有抽象方法（推荐）

由此可见：

A：具体类多态（几乎没有）

B：抽象类多态（常用）

C：接口多态（最常用）

接口成员特点：

成员变量：接口中的变量默认（只能）是常量。并且是静态的。

有默认修饰符：publicstatic final

构造方法：没有构造方法。接口主要是扩展功能。

成员方法：默认修饰符public，只能是抽象方法。

所有的类都默认继承一个类：object,它是类层次结构的根类。

接口之间关系：

类与类：继承关系，只能单继承，可以多层继承。

类与接口：实现关系。可以单实现，也可以多实现，并且还可以在继承一个类                的同时实现多个接口。

接口与接口：继承关系。可以单继承，也可以多继承。

抽象类和接口的区别：

A：成员区别：

抽象类：

        成员变量：可以变量，也可以常量

        构造方法：有

        成员方法：可以抽象，也可以非抽象

    接口：

        成员变量：只可以常量

        成员方法：只可以抽象

B：关系区别：

类与类

        继承，单继承

    类与接口

        实现，单实现，多实现

    接口与接口

        继承，单继承，多继承

       

C：设计理念不同：

    抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系        的共性功能。

    接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的        扩展功能

十、

1、形参和返回值问题

形式参数：基本类型、引用类型

引用类型：类（匿名对象时讲过）：需要的是该类的对象

抽象类：需要的是该抽象类的子类

接口：需要的是该接口的实现类对象

返回值类型：基本类型、引用类型

引用类型：类：返回的是该类的对象

抽象类：返回的是该抽象类的子类对象

接口：返回的是接口的实现类的对象

2、链式编程：对象调方法再调方法。每次调用完后，返回的是一个对象。

3、包：就是文件夹

作用：把相同类名放到不同文件夹中；对类进行分类管理。

定义：package 包名

面试题：package、import、class有没有顺序？

有，package>import>class

Package：只能有一个

Import：可以有多个

Class：可以有多个，建议用一个