黑马程序员_Java语言_面向对象_内部类

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

10.01_面向对象(package关键字的概述及作用)

A:为什么要有包

将字节码(.class)进行分类存放

B:包的概述//相当于文件夹

C:包的作用

10.02_面向对象(包的定义及注意事项)

A:定义包的格式

package 包名;

定义包

关键字 package 包名;

包名：字母全部小写，如果是多级包 使用.分开

package cn.itcast.test

class A{}
cn.itcast.test.A
package定义包，整个文件的最上方
包是不能重复定义的，只能写一次

多级包用.分开即可

B:定义包的注意事项

A:package语句必须是程序的第一条可执行的代码

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

C:如果没有package，默认表示无包名

C:案例演示

包的定义及注意事项

10.03_面向对象(带包的类编译和运行)

A:如何编译运行带包的类

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

javac -d . HelloWorld.java

b:通过java命令执行。

java 包名.HellWord

10.04_面向对象(不同包下类之间的访问)

A:案例演示

不同包下类之间的访问

/*
定义包，
写类，调用别的包中的类的方法
*/
package packa;
import packb.PackB;
class  PackA
{
public static void main(String[] args)
{
PackB pb = new PackB();
pb.show();

//  packc.PackC pc = new packc.PackC();
//  pc.haha();
//  System.out.println("Hello World!");
}
}

package packb;
public class PackB extends packc.PackC
{
public PackB(){}
public void show(){
System.out.println("packb...show");
haha();
}
}

package packc;
public class PackC
{
//受保护的权限，只给子类使用
protected void haha(){
System.out.println("c类方法haha");
}
}

10.05_面向对象(import关键字的概述和使用)

A:案例演示

为什么要有import//从JDK1.4开始，每个类，默认 import java.lang.*;

B:导包格式

import 包名;

注意：

这种方式导入是具体到类的名称。

虽然可以最后写 .*，但是不建议。

C:package,import,class有没有顺序关系(面试题)

依次

10.06_面向对象(四种权限修饰符的测试)

A:案例演示

四种权限修饰符

B:结论

本类 同一个包下(子类和无关类) 不同包下(子类) 不同包下(无关类)

private Y

默认 Y Y

protected Y Y Y

public Y Y Y Y

10.07_面向对象(类及其组成所使用的常见修饰符)

A:修饰符：

权限修饰符：private，默认的，protected，public

状态修饰符：static，final

抽象修饰符：abstract

B:类：

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

状态修饰符：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

10.08_面向对象(内部类概述和访问特点)

A:内部类概述//在一个类的内部，定义一个类

B:内部类访问特点

a:内部类可以直接访问外部类的成员，包括私有。

b:外部类要访问内部类的成员，必须创建对象。

C:案例演示

内部类极其访问特点

/*
成员内部类的使用格式
*/
class Outer
{
int i = 3 ;
class Inner
{
int i = 4;
public  void show(){
int i = 5;
System.out.println("inner.show"+Outer.this.i);
}
}

}
class InnerClassDemo
{
public static void main(String[] args)
{
//Outer.Inner oi = new Outer.Inner();
//oi.show();
//Outer.Inner.show();
Outer.Inner oi = new Outer().new Inner();
oi.show();
//new Outer().method();
//System.out.println("Hello World!");
}
}

10.09_面向对象(成员内部类私有使用)

private

10.10_面向对象(静态成员内部类)

static

B:成员内部类被静态修饰后的访问方式是:

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

格式1 ： 内部类是非静态的，内部类的方法是非静态的
外部类.内部类  变量 = new 外部类对象().new内部类对象();
变量.内部类方法();

格式2： 内部类静态，内部类方法静态
外部类.内部类.内部类方法();

格式3： 内部类是静态的，内部类方法非静态
外部类.内部类 变量 = new 外部类.内部类对象();

10.11_面向对象(成员内部类的面试题)

A:面试题

要求：使用已知的变量，在控制台输出30，20，10。

class Outer {
public int num = 10;
class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(?);//num
System.out.println(??);//this.num
System.out.println(???);//Outer.this.num
}
}
}
class InnerClassTest {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}

10.12_面向对象(局部内部类访问局部变量的问题)

A:案例演示

局部内部类访问局部变量必须用final修饰

生命周期： 对象生存时间大于方法的局部生存时间
加final后，可以访问，但是变量的生命定义的区间有关，和是不是final没有任何关系

为什么加final可以通过，javac编译，变了戏法，变量值直接赋值到方法中

jdk1.8不需要final了

10.13_面向对象(匿名内部类的格式和理解)

A:匿名内部类

就是内部类的简化写法。

B:前提：必须有继承类，或者实现接口

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

C:格式：

new 类名或者接口名(){

重写方法;

}

D:本质是什么呢?

是一个继承了该类或者实现了该接口的子类匿名对象。

E:案例演示

按照要求来一个匿名内部类

interface Inter{
public abstract void show();
public abstract void show2();
}
/*
class InterImpl implements Iner{
public void show(){

}
}
main(){
new InterImpl().show();
}
匿名内部类，简化上面的书写
匿名内部类写在一个类的方法中
*/
class Outer
{
public void method(){
//匿名内部类，简化书写
//new开始到分号结束，直接看成是接口的实现类的一个对象
Inter i =  new Inter(){
public void show(){
System.out.println("重写接口show");
}

public void show2(){
System.out.println("重写接口show2");
}
};
i.show();
i.show2();

}
}
class NiMingDemo
{
public static void main(String[] args)
{
Outer o = new Outer();
o.method();
System.out.println("Hello World!");
}
}

10.14_面向对象(匿名内部类的方法调用)

A:案例演示

匿名内部类的方法调用

interface A
{
public abstract void a();
}
class AImpl implements A
{
public void a(){
System.out.println("重写接口A方法");
}

}

class NiMingTest
{
public  A  getA(){
//匿名内部类，实现结果
return new A(){
public void a(){
System.out.println("匿名内部类");
}
};
}
}

class NiMingDemo1
{
public static void main(String[] args)
{
NiMingTest n = new NiMingTest();
A a = n.getA();
a.a();
//System.out.println("Hello World!");
}
}

10.15_面向对象(匿名内部类在开发中的应用)

A:代码如下

//这里写抽象类，接口都行
abstract class Person {
public abstract void show();
}

class PersonDemo {
public void method(Person p) {
p.show();
}
}

class PersonTest {
public static void main(String[] args) {
//如何调用PersonDemo中的method方法呢?
PersonDemo pd = new PersonDemo ();
//见下
}
}

pd.method(new Person() {
public void show() {
System.out.println("ss");
}
});

10.16_面向对象(匿名内部类的面试题)

A:面试题

按照要求，补齐代码

interface Inter { void show(); }

class Outer { //补齐代码 }

class OuterDemo {

public static void main(String[] args) {

Outer.method().show();

}

}

要求在控制台输出”HelloWorld”

public static Inter method() {
return new Inter() {
public void show() {
System.out.println("HelloWorld");
}
};