javaSE第十天

第十天 57

1. 形式参数和返回值的问题(理解) 57

(1)形式参数： 57

(2)返回值类型： 57

第十天

1. 形式参数和返回值的问题(理解)

(1)形式参数：

类名：需要的是该类的对象

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

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

(2)返回值类型：

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

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

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

(3)链式编程

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

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

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

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

2. 包(理解)

(1)其实就是文件夹

(2)作用：

A:区分同名的类

B:对类进行分类管理

a:按照功能分

b:按照模块分

(3)包的定义(掌握)

package 包名;

多级包用.分开。

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

A:package语句必须在文件中的第一条有效语句

B:在一个java文件中，只能有一个package

C:如果没有package，默认就是无包名

(5)带包的编译和运行

A:手动式

a: 编写一个带包的 java 文件

b: 通过javac 命令编译该java文件

c: 手动创建包名

d: 把b步骤的class文件放到c步骤的最底层包

e: 回到和包根目录在同一目录的地方，然后运行

B:自动式(掌握)

a: 编写一个带包的 java 文件

b: javac编译的时候带上 -d 即可

c: 回到和包根目录在同一目录的地方，然后运行

javac -d . HelloWorld.java

3. 导包(掌握)

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

(2)格式：

import 包名...类名;

另一种：

import 包名...*;(不建议)

(3)package,import,class的顺序

package > import > class

Package：只能有一个

Import：可以有多个

Class：可以有多个，但是建议是一个

4. 权限修饰符(掌握)

(1)权限修饰符

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

private Y

默认 Y Y

protected Y Y Y

public Y Y Y Y

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

public class Demo {}

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

(1)分类：

权限修饰符：private,默认,protected,public

状态修饰符：static,final

抽象修饰符：abstract

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

类：

权限修饰符：默认修饰符、public

状态修饰符：final

抽象修饰符：abstract

用的最多的是：public

成员变量：

权限修饰符：private,默认,protected,public

状态修饰符：static 、 final

用的最多的是：private

构造方法：

权限修饰符：private,默认,protected,public

常用的：public

成员方法：

权限修饰符：private,默认,protected,public,

状态修饰符：static,final

抽象修饰符：abstract

常用的：public

(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

注意：

内部类和外部类之间没有继承关系
通过外部类名限定this对象

Outer.this

class Outer {

public int num = 10;

class Inner {

public int num = 20;

public void show() {

int num = 30;

System.out.println(num);// 30

System.out.println(this.num);// 20

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

}

(6)局部内部类

局部内部类特点：

可以直接访问外部类的成员
在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

面试题：

局部内部类访问局部变量的注意事项？

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

B:为什么呢?

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

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

为了让该值还存在，就加final修饰。

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

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

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

B:前提

存在一个类或者接口

这里的类可以是具体类也可以是抽象类

C:格式:

new 类名或者接口名() {

重写方法;

}

D:本质：

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

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

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

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

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

interface Person {

public abstract void study();

}

class PersonDemo {

public void method(Person p) {

p.study();

}

class PersonTest {

public static void main(String[] args) {

PersonDemo pd = new PersonDemo();

pd.method(new Person() {

public void study() {

System.out.println("好好学习，天天向上");

}

});

}

(9)匿名内部类的面试题

interface Inter {

void show();

}

class Outer {

// 补齐代码

public static Inter method() {

return new Inter() {

public void show() {

System.out.println("HelloWorld");

}

};

}

class OuterDemo {

public static void main(String[] args) {

Outer.method().show(); // "HelloWorld"

* 分析： 1. Outer.method() 可以看出method() 应该是 Outer 类中的一个静态方法 2.

* Outer.method().show() 可以看出 method() 方法的返回值是一个对象，又由于接口Inter
中有一个

* show() 方法，所以我认为 method() 方法的返回值类型是一个Inter
接口

}