自学Java基础知识第十天

day10

1. 内部类(了解)

1.1 内部类的介绍

将一个类定义在另外一个类的内部, 这个类称为内部类; 内部类可以定义在成员位置, 也可以定义在方法中, 根据内部类定义的位置不同, 因此分为成员内部类和局部内部类
为什么定义内部类:

定义出一个Body身体类

class Body{// 外部类

class Heart{// 内部类

// 心脏属性 : 颜色, 心跳, 血压功能 : 跳动,供血, 于是认为将心脏定义成一个类, 表示心脏属性和功能

}

根据内部类定义位置不同:

a : 成员内部类(成员内部类, 理解成一个成员变量在使用)

普通成员内部类

私有成员内部类

静态成员内部类

b: 局部内部类(定义在方法中的内部类)

普通局部内部类

匿名内部类(掌握)

1.2 普通成员内部类

定义位置: 内部类定义在外部类的成员位置
格式:

class Body{// 外部类

class Heart{// 普通成员内部类

// 属性, 方法功能

}

普通成员内部类的使用:

1) 普通成员内部类可以直接使用外部类中的成员

2) 在外部类中想要使用内部类中的成员内容, 需要创建出一个内部类对象, 内部类对象.调用内部类中的属性,功能

3) 普通成员内部类, 想要在其他类型中直接使用内部类, 有公式创建出内部类对象:

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

代码

package com.ujiuye.inner;

public class Body {// 外部类

// blood 表示血压概念

int blood = 120;

class Heart{// Heart类理解成一个普通的成员变量

int jump = 100;

public void show() {

// 1)普通成员内部类可以直接使用外部类中的成员

System.out.println("血压" + blood + ",每分钟心跳为" + jump);

}

// 定义出方法功能 : 使用内部类Heart

public void useHeart() {

System.out.println(blood);

// 创建出一个内部类对象

Heart h = new Heart();

System.out.println(h.jump);

h.show();

}

package com.ujiuye.inner;

public class TestInnerClass {

public static void main(String[] args) {

// 1. 测试普通成员内部类

Body b = new Body();

b.useHeart();

System.out.println(b.blood);

System.out.println("--------------------");

// 在其他的类中, 获取出普通成员内部类对象

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

Body.Heart heart = new Body().new Heart();

System.out.println(heart.jump);

heart.show();

}

1.3 私有成员内部类

定义位置: 内部类定义在外部类的成员位置,但是需要使用private关键字修饰内部类
格式 :

class Body1{// 外部类

private class Gan{// 私有成员内部类

// 属性, 方法功能

}

私有成员内部类使用:

1) 私有成员内部类可以直接使用外部类中的成员

2) 私有成员内部类只能在外部类中创建出对外公共访问方式, 因为私有成员在其他类型中无法直接访问

代码

package com.ujiuye.inner;

public class Body1 {// 外部类

// 私有成员在本类中使用一切正常, 不能在其他类型中直接使用

private int day = 1;

public int getDay() {

return day;

}

public void setDay(int day) {

this.day = day;

}

// 定义出一个私有成员内部类

private class Gan{// 将Gan理解成一个私有成员变量

String color = "灰色";

int drink = 10;

public void show() {

System.out.println(day + "天,喝" + drink + "斤白酒,你的肝颜色变成:" + color);

}

// 定义出一个功能 : 提供私有成员内部类Gan对外公共访问方式

public void useGan() {

// 1. 创建出一个私有成员内部类对象

Gan gan = new Gan();

System.out.println(gan.color + "---" + gan.drink);

gan.show();

}

package com.ujiuye.inner;

public class TestInnerClass {

public static void main(String[] args) {

// 2. 测试私有成员内部类

Body1 b1 = new Body1();

b1.useGan();

}

1.4 静态成员内部类

定义位置: 内部类定义在外部类的成员位置,但是需要使用static关键字修饰内部类
格式:

class Body2{ // 外部类

static class Shen{// 静态成员内部类

// 属性, 方法

}

静态成员内部类使用:

1) 静态成员内部类中,可以直接使用外部类中的静态成员, 但是外部类中的非静态成员, 需要先创建出外部类对象, 使用外部类对象.调用

2) 静态成员内部类中的非静态变量和方法功能, 需要创建出静态成员内部类对象, 使用对象名.调用

语法结构:

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

代码

package com.ujiuye.inner;

public class Body2 {

// 静态属于类, 不属于任何对象, 但是可以被对象共享使用

// 静态中不能直接使用非静态(包括成员变量, 非静态方法), 非静态要使用,

// 需要创建出对象, 使用对象名.调用

static int day = 1;

int drink = 5;

// 定义出一个静态成员内部类

static class Shen{ // 静态成员内部类理解成一个静态成员变量

static int wc = 6;

int i = 10;

public void show() {

// 创建出一个外部类类型Body2

Body2 b2 = new Body2();

// 1)静态成员内部类中,可以直接使用外部类中的静态成员, 但是外部类中的非静态成员,

// 需要先创建出外部类对象, 使用外部类对象.调用

System.out.println(day + "天" + "喝了" + b2.drink + "升水,去排毒" + wc + "次, 少了, 如果去了"+ i +"次会更好");

}

package com.ujiuye.inner;

public class TestInnerClass {

public static void main(String[] args) {

// 3. 测试静态成员内部类

System.out.println(Body2.Shen.wc);// 6

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

Body2.Shen shen = new Body2.Shen();

System.out.println(shen.i);

shen.show();

}

1.5普通局部内部类

定义位置: 局部内部类定义在方法当中
格式:

public void breath(){// 方法

class Fei{// 局部内部类

// 属性,方法功能

}

局部内部类使用:

1) 局部变量定义在方法中, 跟着方法运行存在于内存中, 跟着方法运行完毕,出内存, 无法单独获取到方法中的局部变量

2) 同理, 局部内部类, 无法单独获取到, 局部内部类只能在当前定义方法中进行使用, 于是在方法中,创建出局部内部类对象, 通过对象.调用布局内部类中的属性和功能,外界通过调用局部内部类所在的方法,相当于对局部内部类进行使用

代码

package com.ujiuye.inner;

public class Demo01_局部内部类 {

public static void main(String[] args) {

breath();

}

public static void breath() {

int count = 10; // 局部变量

// 定义出局部内部类

class Fei{// 局部内部类理解成一个局部变量使用

String color = "黑色";

public void somke() {

System.out.println("每天吸" + count + "根烟,慢慢的肺有可能会变成" + color);

}

System.out.println(count);// 10

// 创建出局部内部类对象

Fei fei = new Fei();

System.out.println(fei.color);// 黑色

fei.somke();// 每天吸10根烟,慢慢的肺有可能会变成黑色

}

1.5 匿名内部类(掌握)

匿名对象: new Person();

匿名对象只能使用一次

new Person().属性或者方法;

匿名内部类本质:

匿名内部类可以作为一个类的子类或者作为一个接口的实现类

匿名内部类语法结构:

语法整体是一个匿名内部类的对象创建

new 父类或者父接口(){

// 重写父类和父接口中需要重写方法功能

};

a : 匿名内部类对象, 只能使用一次

b : 优化匿名内部类对象使用

在创建好匿名内部类对象之后, 使用多态的方式, 以匿名内部类实现的父类或者父接口作为等号左边的变量引用, 等号右边是匿名内部类对象, 多态表达式成立, 可以多次使用匿名内部类中重写和继承到的方法和属性功能

代码

package com.ujiuye.inner;

public class Demo02_匿名内部类 {

// 匿名内部类可以简化类与接口实现关系

public static void main(String[] args) {

// 整段匿名内部类代码表示创建出一个MyInter实现类对象,只能使用一次

new MyInter() {// 一对大括号就表示接口MyInter实现类,大括号中是实现过程

@Override

public void fun() {

System.out.println("我是匿名内部类实现的fun"+I);

}

}.fun();

// 匿名内部类实现接口MyInter2

// 父接口名 = 实现类对象; 多态

MyInter2 my = new MyInter2() {

// 大括号表示MyInter2接口的实现类, 实现过程

@Override

public int getSum(int x, int y) {

return x + y;

}

@Override

public void print(String s) {

System.out.println(s);

}

};

my.print("123");// 123

System.out.println(my.getSum(5, 6));// 11

}

interface MyInter{

int I = 10;

public abstract void fun();

}

interface MyInter2{

public abstract int getSum(int x, int y);

public abstract void print(String s);

}

2. 4种权限修饰符

4种权限修饰 : 表示作用范围

public : 公共的, 最大使用权限, 当前项目工程下都可以使用

protected : 受保护权限, 关键字, 能体现出封装

默认权限 : 定义类, 接口, 方法, 成员变量, 没有给出任何权限修饰, 那么默认权限, 默认权限不能写出来, 写出来报错

private : 私有, 最小使用权限, 当前类中使用

4种权限使用范围

	本类中使用	本包中使用	外包子类中使用	外包中无关类
private	可以
默认权限	可以	可以
protecte受保护权限	可以	可以	可以
public 公共权限	可以	可以	可以	可以

注意 :

protected : 受保护权限,可以在外包子类内部使用, 出了子类之外,无法使用

受保护的权限被外包子类继承到, 在子类中相当于private私有使用

代码

package com.ujiuye.quanxian;

// 默认修饰的类

class Demo01_默认修饰类 {

// 默认修饰的成员

int i = 10;

public void useI() {

System.out.println(i);

}

package com.ujiuye.quanxian;

public class Demo02_受保护权限 {

protected int pro = 20;

// fun是一个受保护权限修饰

protected void fun() {

System.out.println(pro);

}

package com.ujiuye.quanxian;

public class Demo03_公共权限 {

int i = 10;

public void function() {

System.out.println("--------------" + i);

}

package com.ujiuye.quanxian;

public class Test权限 {

public static void main(String[] args) {

// 1. 测试默认权限修饰的类,可以在同一个package包下使用

Demo01_默认修饰类 demo = new Demo01_默认修饰类();

System.out.println(demo.i);// 10

demo.useI();// 10

// 2. 测试受保护权限在同一个package包下使用

Demo02_受保护权限 demo2 = new Demo02_受保护权限();

System.out.println(demo2.pro);

demo2.fun();

// 3. 测试公共权限在本包中可以使用

Demo03_公共权限 demo3 = new Demo03_公共权限();

demo3.function();

}

package com.ujiuye.otherquanxian;

import com.ujiuye.quanxian.Demo02_受保护权限;

public class Demo02受保护权限Sub extends Demo02_受保护权限 {

// 继承到了父类中的受保护成员变量pro, 受保护方法功能 fun

// 受保护权限只能在外包子类中的使用

public void useProtected() {

System.out.println(pro);

fun();

}

package com.ujiuye.otherquanxian;

import com.ujiuye.quanxian.Demo02_受保护权限;

import com.ujiuye.quanxian.Demo03_公共权限;

public class Test外包权限 {

public static void main(String[] args) {

// Demo01_默认修饰类 demo = new Demo01_默认修饰类(); 默认权限无法在外包中使用

// 测试受保护权限在外包子类中保护程度

Demo02受保护权限Sub demo2Sub = new Demo02受保护权限Sub();

demo2Sub.useProtected();

// System.out.println(demo2Sub.Pro); 受保护的权限被外包子类继承到, 在子类中相当于private私有使用

Demo02_受保护权限 demo2 = new Demo02_受保护权限();

// demo2.pro; 受保护的权限在外包无关类中不能使用

// 测试公共权限在外包子类的使用

Demo03公共权限Sub demo3 = new Demo03公共权限Sub();

demo3.function();

// 测试公共权限在外包无关类中使用

Demo03_公共权限 pub = new Demo03_公共权限();

pub.function();

}

3. API和类库

3.1 API的使用

API : 全称应用程序接口, API是JDK给开发人员提供的参考文档(帮助文档), 因为JDK给开发人员提供很多的核心类库功能, 所以对应有帮助文档, 为了解释说明 : 类型的功能, 构造方法, 成员变量, 方法功能等使用规则
每一个JDK版本都对应有API帮助参考文档
如何使用API:

1) 双击打开对应的API帮助文档

3.2 类库

java源文件.java文件, 编译后的文件.class字节码文件, 最终在内存中运行的就是.class文件, 因为.class文件中包含了类型中的所有内容
实际开发中项目工程中很多的包, 每个包下有很多的独立类型文件, 最终需要将实现的代码功能交付给客户, 就是交付.class文件, 需要将大量的.class文件进行打包, 生成一个jar包, jar包是java中的代码标准压缩包, 只要在项目中导入jar包, 那么这个jar包中的所有的类型都可以使用和运行
JDK的核心类库

将代码打包成jar包文件:

1) 选中需要打成jar包的项目工程或者是package包

2) 点击选中的工程或者包

鼠标右键--->export-->java--->jar file--->选择jar文件存放的路径和定义jar文件的名称-->finish完成即可

如何将jar包导入到项目工程中使用:

1) 复制需要使用的jar包, 到项目工程根目录下

2) 将jar包下的所有的文件路径导入到项目工程中, 目标jar包变成奶瓶标志, 然后目标jar包中的类型就可以使用

效果:

删除不需要的jar包:

4. Object类型

4.1 Object类型的概述

Object类 : 所有类的父类 , 来自于java.lang包, 使用不需要导包

Object类是所有类的父类:

如果类没有手动继承父类,那么Object类就是这个类的直接父类

class A{} // Object类就是A的父类

class B extends A{}

Object类中有一个空参数构造:

空参数构造中第一行不再调用super(), 因为Object类没有父类,创建对象, 正常;

4.2 toString方法

toString() : 将调用toString方法的对象以字符串形式进行表示, 将字符串进行返回

toString方法源代码:

public String toString() {

com.ujiuye.object.Person @ 15db9742

return getClass().getName() + "@" + Integer.toHexString(hashCode());

}

1) getClass().getName() : 表示获取当前类型的全名

2) "@" : 字符串@

3) hashCode() : 表示计算出一个对象的哈希值, 就是将一个对象在内存中的物理地址, 转换成程序员可以理解数据形式, int类型整数

4) Integer.toHexString(int i) : 表示将参数的int类型整数转换成16进制数进行表示

结果 : com.ujiuye.object.Person@15db9742 称为对象的地址

实际开发中, 输出打印对象的内存地址没有意义, 因此,需要Object的子类重写父类中的toString方法功能, 不需要自己重写, 使用快捷键 alt + shift + s , 选择toString, 重写之后会将当前对象中的成员变量内容进行输出

println就是一个输出打印的方法 : 如果输出的是引用数据类型, 那么方法功能自动调用对象中的toString方法

代码

package com.ujiuye.object;

// 因为Person没有直接父类, 那么object就是Person的父类

public class Person {

private String name;

private int age;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

@Override

public String toString() {

return "Person [name=" + name + ", age=" + age + "]";

}

package com.ujiuye.object;

public class Test {

public static void main(String[] args) {

Person p = new Person();

String s = p.toString();

System.out.println(s); // Person [name=null, age=0]

// println就是一个输出打印的方法 : 如果输出的是引用数据类型, 那么方法功能自动调用对象中的toString

// 方法作为输出结果

System.out.println(p); // Person [name=null, age=0]

}