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

用户9184480

发布于 2024-12-13 14:52:18

11900

代码可运行

文章被收录于专栏：云计算linux云计算linux

运行总次数：0

代码可运行

day09-JAVAOOP

课程目标

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

一.内部类

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文件，但是前面冠以外部类的类名和

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

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

五.权限修饰符

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();
        f.show4();

        Son s = new Son();
        s.publicShow1();
        s.protectedShow3();
        s.show4();
    }
}

同一包下（无关类）

package cn.yanqi.soft1;

/**
 * @Auther: yanqi
 * @Desc 同一包无关类，可以访问除私有以外的所有方法
 */
public class Test {
    public static void main(String[] args) {
        Father f = new Father();
        f.publicShow1();
        f.protectedShow3();
        f.show4();
    }
}

不同包下（子类）

package cn.yanqi.soft2;
import cn.yanqi.soft1.Father;
/**
 * @Auther: yanqi
 * @Desc  不同包子类，只能访问 public protected
 */
public class Son2 extends Father {
    public static void main(String[] args) {
        Son2 s = new Son2();
        s.publicShow1();
        s.protectedShow3();        
    }
}

不同包下（无关类）

package cn.yanqi.soft2;
import cn.yanqi.soft1.Father;
/**
 * @Auther: yanqi
 * @Date: 11:29
 * @Desc  不同包下的无关类，只能访问 pubLic
 */
public class Test2 {
    public static void main(String[] args) {
        Father f = new Father();
        f.publicShow1();
    }
}

小结

在四大权限中，public是最大的权限，private是最小的权限

在编写代码时，如果没有特殊的考虑，建议以下使用方式;

成员变量使用 private ，隐藏细节。

构造方法使用 public ，方便创建对象。

成员方法使用 public ，方便调用方法

六.static关键字

6.1什么是static关键字

它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。

6.2 static的定义和使用格式

static的特点：(它可以修饰成员变量，还可以修饰成员方法)
		A:随着类的加载而加载
			回想main方法。
		B:优先于对象存在
		C:被类的所有对象共享
			举例：咱们班级的学生应该共用同一个班级编号。
			其实这个特点也是在告诉我们什么时候使用静态?
				如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
			举例：
				饮水机(用静态修饰)
				水杯(不能用静态修饰)
		D:可以通过类名调用
			其实它本身也可以通过对象名调用。
			推荐使用类名调用。
			
			静态修饰的内容一般我们称其为：与类相关的，类成员

6.3.1静态变量

public class Student {
    //非静态变量
    int num1 = 10;
    //静态变量
    static int num2 = 20;
}
public class StudentDemo {
    public static void main(String[] args) {
        Student s = new Student();

        System.out.println(s.num1);
        System.out.println(s.num2);//也可以用对象来调用静态变量，不推荐

        //可以直接用类名直接调用静态变量
        System.out.println(Student.num2);
    }
}

6.3.2静态方法

static关键字注意事项
		A:在静态方法中是没有this关键字的
			如何理解呢?
				静态是随着类的加载而加载，this是随着对象的创建而存在。
				静态比对象先存在。
		B:静态方法只能访问静态的成员变量和静态的成员方法
				静态方法：
					成员变量：只能访问静态变量
					成员方法：只能访问静态成员方法
				非静态方法：
					成员变量：可以是静态的，也可以是非静态的
					成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
			简单记：
				静态只能访问静态。非静态可以访问静态也可以访问非静态

public class Student {
    //非静态变量
    int num1 = 10;
    //静态变量
    static int num2 = 20;

    //非静态方法
    public void show(){
        System.out.println(num1);
        System.out.println(this.num1);
        System.out.println(num2);

        //方法：非静态的可以访问静态的也可以访问非静态的
        function();
        function2();
    }
    //静态方法
    public static void method(){
        //静态不能访问非静态的成员变量
        // System.out.println(num1);

        //静态中没有this
        // System.out.println(this.num1);

        //静态方法可以访问静态的成员变量
        System.out.println(num2);

        //静态不能访问非静态的
        // function();

        //静态可以访问静态的
        function2();
    }


    public void function(){
        System.out.println("function");
    }

    public static void function2(){
        System.out.println("function2");
    }
}

注意事项

静态方法可以直接访问类变量和静态方法。
静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。
静态方法中，不能使用this关键字。

6.3.3调用格式

被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属于一个类，共享使用同一个静态成员，但是不建议，会出现警告信息

格式

// 访问类变量 
类名.类变量名；    
// 调用静态方法 
类名.静态方法名(参数)；

6.3.4static小结

被static修饰的内容

是随着类的加载而加载的，且只加载一次。

存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。

它优先于对象存在，所以，可以被所有对象共享。

6.3.5静态变量和成员变量的区别

所属不同
	静态成员变量属于类，所以也称为类变量
	成员变量属于对象，所以也称之为实例变量(对象变量)
内存中位置不同
	静态变量存储于方法区的静态区
	成员变量存储于堆内存中
内存出现的时间不同
	静态变量随着类的加载而加载，随着类的消失而消失
	成员变量随着对象的创建而创建，随着对象的消失而消失
调用不同
	静态变量可以通过类名调用，也可以通过对象来调用
	成员变量只能通过对象名调用

6.3静态代码块

什么是静态代码块

定义在成员位置，使用static修饰的代码块{}。

位置：类中方法外。

执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

静态代码块格式

public class ClassName{ 
   static {
       // 执行语句 
   }
}

代码演示

静态代码块的作用主要是给类变量进行初始化赋值。用法演示，代码如下

public class Game {
    static int age;
    static String name;
    static {
        age = 27;
        name = "江一燕";
        System.out.println(name+": "+age);
    }
}

public class GameTest {
    public static void main(String[] args) {
        Game g = new Game();
        Game g2 = new Game();
    }
}

它优先于对象存在，所以，可以被所有对象共享。

[外链图片转存中…(img-YNO9yOV0-1672067188745)]

6.3.5静态变量和成员变量的区别

所属不同
	静态成员变量属于类，所以也称为类变量
	成员变量属于对象，所以也称之为实例变量(对象变量)
内存中位置不同
	静态变量存储于方法区的静态区
	成员变量存储于堆内存中
内存出现的时间不同
	静态变量随着类的加载而加载，随着类的消失而消失
	成员变量随着对象的创建而创建，随着对象的消失而消失
调用不同
	静态变量可以通过类名调用，也可以通过对象来调用
	成员变量只能通过对象名调用

6.3静态代码块

什么是静态代码块

定义在成员位置，使用static修饰的代码块{}。

位置：类中方法外。

执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

静态代码块格式

public class ClassName{ 
   static {
       // 执行语句 
   }
}

代码演示

静态代码块的作用主要是给类变量进行初始化赋值。用法演示，代码如下

public class Game {
    static int age;
    static String name;
    static {
        age = 27;
        name = "江一燕";
        System.out.println(name+": "+age);
    }
}

public class GameTest {
    public static void main(String[] args) {
        Game g = new Game();
        Game g2 = new Game();
    }
}

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2023-05-14，如有侵权请联系 cloudcommunity@tencent.com 删除

java

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度