JAVA零基础小白学习教程之day09-内部类&权限&final&静态

Posted 2022-12-28 teayear

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JAVA零基础小白学习教程之day09-内部类&权限&final&静态相关的知识，希望对你有一定的参考价值。

day09-JAVAOOP

课程目标

1. 【理解】什么是内部类
2. 【掌握】匿名内部类
3. 【掌握】引用数据类型作为方法的参数
4. 【理解】final关键字的使用
5. 【理解】包的定义及使用
6. 【理解】权限修饰符
7. 【掌握】static关键字的使用

B友https://www.bilibili.com/video/BV1QG4y1J76q

一.内部类

1.1什么是内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

内部类的分类

成员内部类
局部内部类
匿名内部类

1.2成员内部类

在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。比如，汽车类 Car 中包含发动机类 Engine ，这时， Engine 就可以使用内部类来描述，定义在成员位置。

成员内部类格式

class 外部类 
    成员变量
    成员方法
    class 成员内部类

成员内部类访问特点

内部类可以直接访问外部类的成员，包括私有成员。
外部类要访问内部类的成员，必须要建立内部类的对象。

创建内部类对象格式

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

代码演示

定义类

public class Person 
    private boolean live;
    //内部类
    class Heart
        public void jump()            
            //内部类可以直接访问外部类的成员，包括私有
            if (live)
                System.out.println("在跳");
            else
                System.out.println("不在跳");
            
        
    
    public void setLive(boolean live) 
        this.live = live;

测试类
```
public class InnerDemo 
    public static void main(String[] args)        
        //创建外部类对象
        Person p = new Person();
        p.setLive(true);
        //创建内部类对象
        Person.Heart heart = p.new Heart();
        //调用内部类方法
        heart.jump();
    
```
内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名

和 $符号。比如， P erso n$ Heart.class

1.3局部内部类

什么是局部内部类

将一个类定义在一个方法中，该类就称之为是局部内部类

如何使用局部内部类

只能在该方法内部使用局部内部类

代码演示

public class Test 
    public static void main(String[] args) 
        Outer outer = new Outer();
        outer.show();
    

public class Outer 
    public void show()
        // 局部内部类
        class Inner
            public void method()
                System.out.println("Inner 局部内部类的method方法执行了....");
            
        
        // 在外部类的方法内使用局部内部类
        Inner inner = new Inner();
        inner.method();

1.4匿名内部类

是内部类的简化写法。它的本质是一个带具体实现的父类或者父接口的匿名的 子类对象。

开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，似乎得做如下几步操作。

1. 定义实现类 
2. 重写接口中的方法 
3. 创建实现类 对象 
4. 调用重写后的方法

我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式。

使用匿名内部类的前提

匿名内部类必须==继承一个父类或者实现一个父接口==。

匿名内部类的格式

 new 父类名或者接口名()
    // 方法重写
    @Override 
    public void method()         // 执行语句
    
;

匿名内部类的使用

以接口为例，匿名内部类的使用，代码如下：

定义接口

public interface FlyAble
    public abstract void fly();

方式一创建匿名内部类，并调用

public class InnerDemo 
    public static void main(String[] args) 
   		//直接new接口，无需写实现类来实现接口
        new FlyAble()
           //直接实现方法
            public void fly() 
                System.out.println("我飞了~~~");
            
        .fly();

方式二匿名内部类调用。代码如下：

 public class InnerDemo2 
    public static void main(String[] args) 
        FlyAble f = new FlyAble()
            //直接重写抽象方法
            public void fly()
                System.out.println("我要飞，飞啊，飞，，");
            
            @Override
            public void fly2() 
                System.out.println("我要飞，飞啊，飞，，2222");
            
        ;
        f.fly();
        f.fly2();

方式三常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递

public class InnerDemo3 
    public static void main(String[] args) 
        showFly(new FlyAble() 
            @Override
            public void fly() 
                System.out.println("9999999");
            
            @Override
            public void fly2() 
                System.out.println("888888888");
            
        );
    
    public static void showFly(FlyAble f)
        f.fly();
        f.fly2();

匿名内部类好处：就是可以不用再写一个实现类来实现接口，可以直接使用

二.引用类型方法的参数和返回值

实际的开发中，引用类型的使用非常重要，也是非常普遍的。我们可以在理解基本类型的使用方式基础上，进一步去掌握引用类型的使用方式。基本类型可以作为成员变量、作为方法的参数、作为方法的返回值，那么当然引用类型也是可以的

2.1普通类-作为方法的参数及返回值

代码演示：普通类-作为方法的形参

普通类-作为方法的形参

方法的形参是类名，其实需要的是该类的对象
实际传递的是该对象的【地址值】

public class Student 
    public void study()
        System.out.println("好好学习，天天向上");
    

public class StudentDemo 
    //把普通类当作一个参数
    public void method(Student student)
        student.study();
    

public class StudentTest 
    public static void main(String[] args) 
        StudentDemo st = new StudentDemo();
        Student s = new Student();
        st.method(s);

代码演示：普通类-作为方法的返回值类型

  普能类-作为方法的返回值
  
  方法的返回值是类名，其实返回的是该类的对象
  实际传递的，也是该对象的【地址值】

public class Student 
    public void study()
        System.out.println("好好学习，天天向上");
    

public class StudentDemo 
    //返回值类型为一个类
    public Student getStudent()
        return  new Student();
    

public class StudentTest 
    public static void main(String[] args) 
        StudentDemo st = new StudentDemo();
        //返回也是一个对象
        Student student = st.getStudent();
        student.study();

2.2抽象类-作为方法的参数及返回值

抽象类作为形参和返回值
- 方法的形参是抽象类名，其实需要的是该抽象类的子类对象
- 方法的返回值是抽象类名，其实返回的是该抽象类的子类对象

代码演示：抽象类作为形参

public abstract class Person 
    public abstract void study();

public class PersonDemo 
    public void method(Person p)
        p.study();
    

//抽象类作为参数，必须实例化
public class Student extends Person 
    @Override
    public void study() 
        System.out.println("好好学习，天天向上！！");
    

//测试
public class PersonTest 
    public static void main(String[] args) 
        PersonDemo pd = new PersonDemo();

        //抽象类需要一个具体类来实现
        Person p = new Student();
        //method的参数是一个抽象类，那抽象类如何实例化呢? 多态的方式
        pd.method(p);

代码演示：抽象类作为返回类型

public abstract class Person 
    public abstract void study();

public class PersonDemo 
    //返回对象是一个抽象类
    public Person getPerson()
        //person是一个抽象类，只能通过多态的方法实例化
        // Person p = new Student();
        // return p;
        return new Student();
    

//具体子类实现抽象类Person
public class Student extends Person 
    @Override
    public void study() 
        System.out.println("好好学习，天天向上！！");
    

//测试
public class PersonTest 
    public static void main(String[] args) 
        PersonDemo pd = new PersonDemo();

        Person person = pd.getPerson();
        person.study();

2.3接口类-作为方法的参数及返回值

接口作为形参和返回值
- 方法的形参是接口名，其实需要的是该接口的实现类对象
- 方法的返回值是接口名，其实返回的是该接口的实现类对象

代码演示: 接口作为形参

public interface Love 
    public abstract void show();

public class LoveDemo 
    //接口作为参数
    public void method(Love love)
        love.show();
    

//子类实现接口
public class LoveImpl implements Love 
    @Override
    public void show() 
        System.out.println("爱一燕");
    

//测试
public class LoveTest 
    public static void main(String[] args) 
        LoveDemo ld = new LoveDemo();
        //需要对接口的参数进行实现化，多态的方法
        Love love = new LoveImpl();
        //参数需要的是一个接口
        ld.method(love);

代码演示: 接口作为返回值

public interface Love 
    public abstract void show();

public class LoveDemo 
    //接口作为返回值
    public Love getLove()
        // 接口不能直接返回，需要实例化，多态的方式
        // Love love = new LoveImpl();
        // return love;
        return new LoveImpl();
    

//子类实现接口
public class LoveImpl implements Love 
    @Override
    public void show() 
        System.out.println("爱一燕");
    

//测试
public class LoveTest 
    public static void main(String[] args) 
        LoveDemo ld = new LoveDemo();

        Love love = ld.getLove();
        love.show();

三.final关键字

3.1 final概述

学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了final关键字，用于修饰不可改变内容。

3.2final特点

final：不可改变。可以用于修饰类、方法和变量。

类：被修饰的类，不能被继承。
方法：被修饰的方法，不能被重写。
变量：被修饰的变量，不能被重新赋值，变成了常量

3.3final的使用

3.3.1修饰类

//final修饰类
public final class Fu
public void show()
System.out.println(“fu…show…”);

//子类不能继承final所修饰的父类
public class Zi extends Fu


> 查询API发现像 public final class String 、 public final class Math 、 public final class Scanner 等，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容

### 3.3.2修饰方法

```java
public  class Fu 
  public final void show()
      System.out.println("fu..show..");
  

public class Zi extends Fu 
  //子类继承父类中的final修饰的方法
  public void show()
      System.out.println("fu..show..");

3.3.3修饰变量

public  class Fu 
    final int num = 10;
    public  void show()
        System.out.println("fu..show..");
    

public class Test 
    public static void main(String[] args) 
        Fu f = new Fu();
        System.out.println(f.num);//10
        // f.num = 20;  final修饰的变量，变成常量，不能进行修改

四.包的定义及规范

4.1分包思想

如果将所有的类文件都放在同一个包下，不利于管理和后期维护

所以，对于不同功能的类文件，可以放在不同的包下进行管理

4.2什么是包

包：本质上就是文件夹

创建包：（单级包、多级包）
- 多级包之间使用 " . " 进行分割
- 多级包的定义规范：公司的网站地址翻转(去掉www)
包的命名规则：字母都是小写

www.baidu.com --> com.baidu.模块功能的名称

com.baidu.当前的项目的名称.模块功能的名称

4.2包的定义

使用package关键字定义包
格式

package 包名; 如果是多级包，中间用"."进行分割
注意：一般情况下，我们不会手动的去给某一个类定义包，使用idea开发工具创建即可

4.3注意事项

package语句必须是程序的第一条可执行的代码
package语句在一个java文件中只能有一个
如果没有package，默认表示无包名

4.4类与类之间的访问

同一个包下的访问
- 不需要导包，直接使用即可
不同包下的访问
- import 导包后访问
- 通过全类名（包名 + 类名）访问

注意：import 、package 、class 三个关键字的摆放位置存在顺序关系

package 必须是程序的第一条可执行的代码
import 需要写在 package 下面
class 需要在 import 下面

我们开发中：分包

功能分包：cn.yanqi.delete cn.yanqi.update cn.yanqi.select cn.yanqi.add，不常用，不建议

业务模块分包：cn.yanqi.user cn.yanqi.admin / cn.yanqi.web cn.yanqi.service cn.yanqi.dao

五.权限修饰符

5.1权限概述

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，

public：公共的 protected：受保护的

default：默认的 private：私有的

5.2不同权限的访问范围

	public	protected	default(空的)	private
同一个类	√	√	√	√
同一包中（子类与无关类）	√	√	√
不同包的子类	√	√
不同包的无关类	√

同一个包下访问

package cn.yanqi.soft1;
/**
 * @Auther: yanqi
 */
public class Father 
    public void publicShow1()
        System.out.println("father-public-show1 ");
    
    private void privateShow2()
        System.out.println("father-private-show2 ");
    
    protected void protectedShow3()
        System.out.println("father-protected-show3 ");
    
    void show4()
        System.out.println("father-默认修改-show4");
    
    public static void main(String[] args) 
        Father f = new Father();
        f.publicShow1();
        f.privateShow2();
        f.protectedShow3();
        f.show4();

同一个包下（子类）

package cn.yanqi.soft1;

/**
 * @Auther: yanqi
 * @Desc  同一包下子类，可以访问除私有以外的所有方法
 */
public class Son extends Father 
    public static void main(String[] args) 
        Father f = new Father();
        f.publicShow1();
        f.protectedShow3()以上是关于JAVA零基础小白学习教程之day09-内部类&权限&final&静态的主要内容，如果未能解决你的问题，请参考以下文章 
 JAVA零基础小白入门上手教程之day22-JDK新特性
 JAVA零基础小白学习教程之day08_接口&多态
 JAVA零基础小白学习教程之day08_接口&多态
 JAVA零基础小白学习教程之day10-API&Object&String
 JAVA零基础小白学习教程之day10-API&Object&String
 JAVA入门零基础小白教程day07_继承&抽象

JAVA零基础小白学习教程之day09-内部类&权限&final&静态

day09-JAVAOOP

课程目标

一.内部类

1.1什么是内部类

成员内部类

局部内部类

匿名内部类

1.2成员内部类

成员内部类格式

成员内部类访问特点

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

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

创建内部类对象格式

代码演示

定义类

测试类

1.3局部内部类

什么是局部内部类

如何使用局部内部类

代码演示

1.4匿名内部类

使用匿名内部类的前提

匿名内部类的格式

匿名内部类的使用

定义接口

方式一 创建匿名内部类，并调用

方式二匿名内部类调用 。代码如下：

方式三 常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递

二.引用类型方法的参数和返回值

2.1普通类-作为方法的参数及返回值

代码演示：普通类-作为方法的形参

代码演示：普通类-作为方法的返回值类型

2.2抽象类-作为方法的参数及返回值

抽象类作为形参和返回值

代码演示：抽象类作为形参

2.3接口类-作为方法的参数及返回值

接口作为形参和返回值

代码演示: 接口作为形参

三.final关键字

3.1 final概述

3.2final特点

3.3final的使用

3.3.1修饰类

3.3.3修饰变量

四.包的定义及规范

4.1分包思想

4.2什么是包

包：本质上就是文件夹

创建包：（单级包、多级包）

多级包之间使用 " . " 进行分割

多级包的定义规范：公司的网站地址翻转(去掉www)

包的命名规则：字母都是小写

4.2包的定义

使用package关键字定义包

格式

4.3注意事项

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

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

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

4.4类与类之间的访问

同一个包下的访问

不需要导包，直接使用即可

不同包下的访问

import 导包后访问

通过全类名（包名 + 类名）访问

五.权限修饰符

5.1权限概述

5.2不同权限的访问范围

同一个包下访问

同一个包下（子类）

方式一创建匿名内部类，并调用

方式二匿名内部类调用。代码如下：

方式三常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递