自学Java基础知识第十天

day10

1. 内部类(了解)

1.1 内部类的介绍

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

   定义出一个Body身体类

   class Body{// 外部类  

      class Heart{// 内部类

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

}

}

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

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

     普通成员内部类

     私有成员内部类

     静态成员内部类

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

     普通局部内部类

     匿名内部类(掌握)

     

1.2 普通成员内部类

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

   class Body{// 外部类

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

// 属性, 方法功能

}

}

1. 普通成员内部类的使用:

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 私有成员内部类

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

   class Body1{// 外部类

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

          // 属性, 方法功能

}

}

1. 私有成员内部类使用:

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 静态成员内部类

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

  class Body2{ // 外部类

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

          // 属性, 方法

}

}

1. 静态成员内部类使用:

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普通局部内部类

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

   public void breath(){// 方法

       class Fei{// 局部内部类

           // 属性,方法功能

}

}

1. 局部内部类使用:

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 匿名内部类(掌握)

1. 匿名对象: new Person();

  匿名对象只能使用一次

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

1. 匿名内部类本质:

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

1. 匿名内部类语法结构:

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

  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种权限修饰符

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

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

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

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

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

1. 4种权限使用范围

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

1. 注意 :

   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的使用

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

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

 

 

 

3.2 类库

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

 

1. 将代码打包成jar包文件:

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

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

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

   

 

 

 

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

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

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

  

效果:

 

   

1. 删除不需要的jar包:

  

 

 

4. Object类型

4.1 Object类型的概述

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

1. Object类是所有类的父类:

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

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

   class B extends A{}

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

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

4.2 toString方法

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

   

1. 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 称为对象的地址

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

 

1. 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]

}

}