欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

final关键字、权限、内部类

程序员文章站 2022-07-08 18:23:48
一:final关键字、权限、内部类1.final 概述​学习了继承后,我们知道,子类可以在父类的基础上改写父类内容,比如,方法重写。那么我们能不能随意的继承API中提供的类,改写其内容呢?显然这是不合适的。为了避免这种随意改写的情况,Java提供了 final 关键字,用于修饰不可改变内容。2.final使用方法final 不可改变的,用来修饰类 、方法、变量类:被修饰的类,不能被继承.方法 : 被修饰的方法,不能被重写.变量:被修饰的变量,不能被重新赋值.使用方法:...

一:final关键字、权限、内部类

1.final 概述

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

2.final使用方法

  • final 不可改变的,用来修饰类 、方法、变量

    • 类:被修饰的类,不能被继承.
    • 方法 : 被修饰的方法,不能被重写.
    • 变量:被修饰的变量,不能被重新赋值.
  • 使用方法:

    • 格式:

      final class 类名{}
      
    • 我们以前学习过的常用类中,有很多都是给我们直接使用的,不可被外界修改的类,都是被final修饰的.

      • public final class String
      • public final class Math
      • public final class Scanner 等
    • final 修饰方法

      • 当final关键字用来修饰一个方法的时候,这个方法就是最终方法,也就是不能被覆盖重写。

      • 格式

        格式:
        修饰符 final 返回值类型 方法名称(参数列表) {
            // 方法体
        }
        
      • 被final修饰的方法不可被重写,重写发生在继承或者接口,就是为了扩展功能,而final定义的是不可变的,因此要切记: final 和abstract 不可同时使用.

      • 注意事项:
        对于类、方法来说,abstract关键字和final关键字不能同时使用,因为矛盾。

    • final修饰变量

      对于成员变量来说,如果使用final关键字修饰,那么这个变量也照样是不可变。

      1. 由于成员变量具有默认值,所以用了final之后必须手动赋值,不会再给默认值了。
      2. 对于final的成员变量,要么使用直接赋值,要么通过构造方法赋值。二者选其一。
      3. 必须保证类当中所有重载的构造方法,都最终会对final的成员变量进行赋值。

二:权限

四种权限修饰符

Java中有四种权限修饰符:
public > protected > (default) > private
同一个类(我自己) YES YES YES YES
同一个包(我邻居) YES YES YES NO
不同包子类(我儿子) YES YES NO NO
不同包非子类(陌生人) YES NO NO NO

注意事项:(default)并不是关键字“default”,而是根本不写。

三:内部类

1.内部类的概念

如果一个事物的内部包含另一个事物,那么这就是一个类内部包含另一个类。

例如:身体和心脏的关系。又如:汽车和发动机的关系。

2.内部类的分类

  1. 成员内部类
  2. 局部内部类[包含匿名内部类]

3.成员内部类

  • ​ 成员内部类的定义格式

    修饰符 class 外部类名称 {
        修饰符 class 内部类名称 {
            // ...
        }
        // ...
    }
    

    注意 :内用外,随便用,外用内,需要内部类对象.

  • 如何使用成员内部类?有两种方式:

    1. 间接方式:在外部类的方法当中,使用内部类;然后main只是调用外部类的方法。
    2. 直接方式,公式:
      类名称 对象名 = new 类名称();
      【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】
  • 代码写法

    public class Body { // 外部类
    
        public class Heart { // 成员内部类
    
            // 内部类的方法
            public void beat() {
                System.out.println("心脏跳动:蹦蹦蹦!");
                System.out.println("我叫:" + name); // 正确写法!
            }
    
        }
    
        // 外部类的成员变量
        private String name;
    
        // 外部类的方法
        public void methodBody() {
            System.out.println("外部类的方法");
            new Heart().beat();
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    
    
  • 测试类

    public class Demo01InnerClass {
      public static void main(String[] args) {
          //先创建一个外部类对象
          Body body = new Body();
    
          /* public void methodBody() {
            System.out.println("外部类的方法");
            new Heart().beat();
        }*/
          //通过调用外部类的方法来访问内部类的方法
          body.methodBody();
          System.out.println("=======");
          //【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】
          Body.Heart heart = new Body().new Heart();
          heart.beat();
    
      }
    }
    
  • 内部类的成员变量重名问题 :如果出现了重名现象,那么格式是:外部类名称.this.外部类成员变量名

    // 如果出现了重名现象,那么格式是:外部类名称.this.外部类成员变量名
    public class Outer {
    
        int num = 10; // 外部类的成员变量
    
        public class Inner /*extends Object*/ {
    
            int num = 20; // 内部类的成员变量
    
            public void methodInner() {
                int num = 30; // 内部类方法的局部变量
                System.out.println(num); // 局部变量,就近原则
                System.out.println(this.num); // 内部类的成员变量
                System.out.println(Outer.this.num); // 外部类的成员变量
            }
    
        }
    
    }
    
    public class Demo02InnerClass {
        public static void main(String[] args) {
            // 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
            Outer.Inner obj = new Outer().new Inner();
            obj.methodInner();
        }
    
    }
    

4.局部内部类(包含匿名内部类)

  1. ​ 概念:

    听到这个概念,顾名思义,就是在外部类的方法里定义了内部类.该内部类仅仅属于这个方法,出了这个方法以外的,就访问不到了.

    如果一个类是定义在一个方法内部的,那么这就是一个局部内部类。
    “局部”:只有当前所属的方法才能使用它,出了这个方法外面就不能用了。

    定义格式:
    修饰符 class 外部类名称 {
        修饰符 返回值类型 外部类方法名称(参数列表) {
            class 局部内部类名称 {
                // ...
            }
        }
    }
    
  2. 代码演示

    class Outer {
    
        public void methodOuter() {
            class Inner { // 局部内部类
                int num = 10;
                public void methodInner() {
                    System.out.println(num); // 10
                }
            }
    		//由于局部内部类的作用域仅仅在当前类中,因此直接这样创建对象使用.
            Inner inner = new Inner();
            inner.methodInner();
        }
    
    }
    
    public class DemoMain {
    
        public static void main(String[] args) {
        	//定义了一个外部类的对象.通过外部类对象来调用他的成员方法.
            Outer obj = new Outer();
            obj.methodOuter();
        }
    
    }
    
  3. 小小总结:

    局部内部类,如果希望访问所在方法的局部变量,那么这个局部变量必须是【有效final的】。

    备注:从Java 8+开始,只要局部变量事实不变,那么final关键字可以省略。

    原因:

    1. new出来的对象在堆内存当中。
    2. 局部变量是跟着方法走的,在栈内存当中。
    3. 方法运行结束之后,立刻出栈,局部变量就会立刻消失。
    4. 但是new出来的对象会在堆当中持续存在,直到垃圾回收消失。

5.匿名内部类[用的最多]

  1. ​ 先举个例子[正常的接口使用步骤]

    • 定义接口

    • 创建接口的实现类,重写接口里的所有抽象方法

    • 实现类.方法名调用.

      public interface MyInterface {
      
          void method1(); // 抽象方法
      
          void method2();
      
      }
      
      public class MyInterfaceImpl implements MyInterface {
          @Override
          public void method1() {
              System.out.println("实现类覆盖重写了方法!111");
          }
      
          @Override
          public void method2() {
              System.out.println("实现类覆盖重写了方法!222");
          }
      }
      
      
       //通过多态的写法来调用方法
       MyInterface obj = new MyInterfaceImpl();
             obj.method();
      
  2. 使用匿名内部类的做法

    • 定义接口,创建抽象方法

    • 创建一个测试类,直接在main 方法 通过匿名内部类的指定格式 new 接口 ,调用方法执行

    • 匿名内部类的格式: 不要忘记分号

      匿名内部类的定义格式:
      接口名称 对象名 = new 接口名称() {
          // 覆盖重写所有抽象方法
      };
      
    • 代码展示

      public class DemoMain {
      
          public static void main(String[] args) {
      //        MyInterface obj = new MyInterfaceImpl();
      //        obj.method();
      
      //        MyInterface some = new MyInterface(); // 错误写法!
      
              // 使用匿名内部类,但不是匿名对象,对象名称就叫objA
              MyInterface objA = new MyInterface() {
                  @Override
                  public void method1() {
                      System.out.println("匿名内部类实现了方法!111-A");
                  }
      
                  @Override
                  public void method2() {
                      System.out.println("匿名内部类实现了方法!222-A");
                  }
              };
           }
       }
      
  3. 使用匿名内部类的注意事项

    • 格式解析

      对格式“new 接口名称() {…}”进行解析:

      1. new代表创建对象的动作
      2. 接口名称就是匿名内部类需要实现哪个接口
      3. {…}这才是匿名内部类的内容
    • 注意问题

      • 匿名内部类,在【创建对象】的时候,只能使用唯一一次。
        如果希望多次创建对象,而且类的内容一样的话,那么就需要使用单独定义的实现类了。
      • 匿名对象,在【调用方法】的时候,只能调用唯一一次。
        如果希望同一个对象,调用多次方法,那么必须给对象起个名字。
      • 匿名内部类是省略了【实现类/子类名称】,但是匿名对象是省略了【对象名称】
    • 强调:匿名内部类和匿名对象不是一回事!!!

      • 匿名内部类:省略了接口的是实现类的书写,直接通过特殊的new接口来创建接口的实现类,并用匿名内部类的名字作为对象名,对方法进行调用.
      • 匿名对象,判断这个对象仅仅会使用一次,不需要给这个对象一个名字,用完了就找不到了.
  4. 使用匿名对象调用方法

    1. 使用了匿名内部类,而且省略了对象名称,也是匿名对象
    2. 因为匿名对象无法调用第二次方法,所以需要再创建一个匿名内部类的匿名对象
    3. 若要重复使用,则不能用匿名的东西.
      new MyInterface() {
                @Override
                public void method1() {
                    System.out.println("匿名内部类实现了方法!111-B");
                }
    
                @Override
                public void method2() {
                    System.out.println("匿名内部类实现了方法!222-B");
                }
            }.method1();
    

6.类作为成员变量类型

  • 知识回顾

    • 定义一个类所需要的那些东西呢?

      • 类要成员变量和成员方法
      • 成员变量可不可以用一个类作为他的成员变量呢 .答案是肯定的.下面我们来模拟一下.
    • 模仿英雄联盟的角色和装备来看,一个英雄,要有名字,要有方法,还要有装备,那么装备也要有名字,装备也要有他自己的功能提供给英雄使用.

      • 定义一个武器类

        public class Weapon {
        
            private String code; // 武器的代号
        
            public Weapon() {
            }
        
            public Weapon(String code) {
                this.code = code;
            }
        
            public String getCode() {
                return code;
            }
        
            public void setCode(String code) {
                this.code = code;
            }
        }
        
        
      • 定义英雄类

        // 游戏当中的英雄角色类
        public class Hero {
        
            private String name; // 英雄的名字
            private int age; // 英雄的年龄
            private Weapon weapon; // 定义一个武器类作为我的一个属性.
        
            public Hero() {
            }
        
            public Hero(String name, int age, Weapon weapon) {
                this.name = name;
                this.age = age;
                this.weapon = weapon;
            }
        
            public void attack() {
                System.out.println("年龄为" + age + "的" + name + "用" + weapon.getCode() + "攻击敌方。");
            }
        
            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;
            }
        
            public Weapon getWeapon() {
                return weapon;
            }
        
            public void setWeapon(Weapon weapon) {
                this.weapon = weapon;
            }
        }
        
        
      • 定义一个测试类

        public class DemoMain {
        
            public static void main(String[] args) {
                // 创建一个英雄角色
                Hero hero = new Hero();
                // 为英雄起一个名字,并且设置年龄
                hero.setName("盖伦");
                hero.setAge(20);
        
                // 创建一个武器对象
                Weapon weapon = new Weapon("AK-47");
                // 为英雄配备武器
                hero.setWeapon(weapon);
        
                // 年龄为20的盖伦用多兰剑攻击敌方。
                hero.attack();
            }
        
        }
        
    • 同理 ,引用类型均可以作为一个类的成员变量.

7.接口作为成员变量类型

  1. 定义一个普通的英雄类,英雄的成员变量需要要给技能的接口.具体的实现看下面的代码.

  2. 定义一个技能接口.

    public interface Skill {
    
        void use(); // 释放技能的抽象方法
    
    }
    
  3. 定义一个技能接口的实现类.

    public class SkillImpl implements Skill {
        @Override
        public void use() {
            System.out.println("Biu~biu~biu~");
        }
    }
    
    
  4. 定义一个英雄类,成员变量需要一个技能接口

    public class Hero {
    
        private String name; // 英雄的名称
        private Skill skill; // 英雄的技能
    
        public Hero() {
        }
    
        public Hero(String name, Skill skill) {
            this.name = name;
            this.skill = skill;
        }
    
        public void attack() {
            System.out.println("我叫" + name + ",开始施放技能:");
            skill.use(); // 调用接口中的抽象方法
            System.out.println("施放技能完成。");
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Skill getSkill() {
            return skill;
        }
    
        public void setSkill(Skill skill) {
            this.skill = skill;
        }
    }
    
    
  5. 定义一个测试类.

    public class DemoGame {
    
        public static void main(String[] args) {
            Hero hero = new Hero();
            hero.setName("艾希"); // 设置英雄的名称
    
            // 设置英雄技能
    //        hero.setSkill(new SkillImpl()); // 使用单独定义的实现类
    
            // 还可以改成使用匿名内部类
    //        Skill skill = new Skill() {
    //            @Override
    //            public void use() {
    //                System.out.println("Pia~pia~pia~");
    //            }
    //        };
    //        hero.setSkill(skill);
    
            // 进一步简化,同时使用匿名内部类和匿名对象
            hero.setSkill(new Skill() {
                @Override
                public void use() {
                    System.out.println("Biu~Pia~Biu~Pia~");
                }
            });
    
            hero.attack();
        }
    
    }
    

8.接口作为方法的参数和方法的返回值

  1. 定义一个方法,传入参数为一个空集合,返回一个装满东西的集合.

    public class DemoInterface {
    
        public static void main(String[] args) {
            // 左边是接口名称,右边是实现类名称,这就是多态写法
            List<String> list = new ArrayList<>();
    
            List<String> result = addNames(list);
            for (int i = 0; i < result.size(); i++) {
                System.out.println(result.get(i));
            }
        }
    
        public static List<String> addNames(List<String> list) {
            list.add("迪丽热巴");
            list.add("古力娜扎");
            list.add("玛尔扎哈");
            list.add("沙扬娜拉");
            return list;
        }
    
    }
    
    

本文地址:https://blog.csdn.net/TiAmonal/article/details/107892364

相关标签: Java高级部分