美文网首页
day11final、权限、内部类

day11final、权限、内部类

作者: __method__ | 来源:发表于2020-07-25 09:32 被阅读0次

final

final 不可改变，可以用于修饰类、方法、变量

  • 类 ：被修饰的类，不能被继承
  • 方法：被修饰的方法， 不能被重写
  • 变量：被修饰的变量、不能被重新赋值

使用

  • 修饰类
    格式如下：
final class 类名 {
}

像 String、Math、Scanner这些类都是被final修饰，目的是供我们呢使用，而不让我们修改。

  • 修饰方法
    格式：
修饰符  final 返回值类型 方法名(参数列表){
          // 方法体
}

如果重写final修饰的方法，编译会报错

  • 修饰变量
  1. 局部变量--基本类型
    基本类型的局部变量，被final修饰后， 只能赋值一次，不能再改
 public static void main(String[] args) {
        // 声明一个变量，被final修饰
        final int a;
        a = 10;
        // a = 20; 不可以

        final  int b = 20;
        // b = 20; 不可以
}

下面哪个可以通过编译
写法一：

final int c = 0;
for (int i = 0; i < 10 ; i++) {
    c = i;
    System.out.println(c);
}

写法二：

for (int i = 0; i < 10 ; i++) {
    final int c = i;
    System.out.println(c);
}

写法一会报错， 写法二会通过编译， 因为每次循环， 都是一个新的c

  1. 局部变量--引用类型
    引用类型的局部变量被final修饰后只能指向一个对象， 但是不影响对象内部的成员变量值的修改。
public static void main(String[] args) {
final User u = new User();
//        User u = new User();
    System.out.println(u);
//        u = new User();
    System.out.println(u);
 // u = new User(); 报错指向了新的对象，地址值改变
    u.userName = "张三"; // 可以对象内部修改成员变量
    System.out.println(u.userName);
}
}
  1. 成员变量
    成员变量涉及到初始化问题，初始化有两种， 只能选一个
  • 显示初始化
public class User {
    // 显示初始化
    final String USERNAME = "张三"; 
}

被final修饰的常量名称， 一般字母都大写
构造方法初始化

public class User {
    final String USERNAME;
    private int age;
    public User(String username, int age) {
        this.USERNAME = username;
        this.age = age;
    }
}

权限修饰符

不同的访问权限修饰符修饰时， 被修饰的内容会有不同的访问权限

  • public 公有的
  • protected 受保护的
  • default 默认的

  • private 私有的



    可见public 具有最大权限，private 最小权限
    建议使用权限：

  • 成员变量使用private ， 隐藏细节
  • 构造方法使用public，方便创建对象
  • 成员方法使用public， 方便调用

不加权限修饰符， 其访问能力与default相同

内部类

将类A定义在另一个类B中，里面的类A就是内部类， B是外部类

  • 成员内部类 ：定义在类中方法外的类
    格式：
class 外部类{
    class 内部类{
}
}

在描述事物时， 若一个事物内部还包含其他事物，就可以使用内部类这种结构， 比如Car中包含Engine， Engine就可以使用内部类来描述

class Car{
    class Engine{
}
}

访问特点

  • 内部类可以直接访问外部类的成员， 包括私有成员。
  • 外部类要访问内部类成员，必须要建立内部类对象
    创建内部类对象的格式
外部类名.内部类名 对象名  = new 外部类型（）.new 内部类型（）；

匿名内部类

匿名内部类: 是内部类的简化写法，它本质是一个带具体实现的父类或者父接口的匿名子类对象。开发中， 最常用到的内部类就是匿名内部类
以接口为例，当你使用一个接口时， 似乎需要如下几步：

  1. 定义子类
  2. 重写接口中所有的方法
  3. 创建子类对象
  4. 调用重写后的方法
    我们的目的是调用方法， 那能否简化一下呢？将四个步骤合为一步呢？
    匿名内部类就可以实现
    前提匿名内部类必须继承一个父类或者实现一个父接口
    格式
new 父类名或父接口（）{
    // 方法重写
  @  Override
  public void method(){
    // 执行语句
}
}

public abstract class FlyAble {
    public abstract  void fly();
}

public class InnerDemo {
    public static void main(String[] args) {
        /**
         * 等号左边：是多态赋值， （抽象类）接口类型引用指向子类对象
         * 等号右边：是匿名内部类， 定义并创建该接口的子类对象
         */

        FlyAble f  =  new FlyAble() {
            @Override
            public void fly() {
                System.out.println("嗷嗷飞");
            }
        };
        System.out.println(f);
        f.fly();
    }
}

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

public class InnerDemo {
    public static void main(String[] args) {

        /**
         * 等号左边：是多态赋值， （抽象类）接口类型引用指向子类对象
         * 等号右边：是匿名内部类， 定义并创建该接口的子类对象
         */

        FlyAble f  =  new FlyAble() {
            @Override
            public void fly() {
                System.out.println("嗷嗷飞");
            }
        };
        System.out.println(f);

        showFly(f);

    }

    public static void showFly(FlyAble flyAble){
        flyAble.fly();
    }

}

简化

package com.neusoft.day11.InnerClassDemo2;

/**
 * @author Eric Lee
 * @date 2020/7/25 11:14
 */
public class InnerDemo2 {
    public static void main(String[] args) {

        showFly(new FlyAble() {
            @Override
            public void fly() {
                System.out.println("嗷嗷飞");
            }
        });

    }

    public static void showFly(FlyAble flyAble){
        flyAble.fly();
    }
}

引用类型用法总结

  • 基本类型可以作为成员变量、方法参数、方法返回值，引用也是可以的

class作为成员变量

package com.neusoft.day11.classMember;

/**
 * @author Eric Lee
 * @date 2020/7/25 11:43
 */
public class Weapon {
    String name;
    int hurt; // 伤害

    public Weapon(String name, int hurt) {
        this.name = name;
        this.hurt = hurt;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getHurt() {
        return hurt;
    }

    public void setHurt(int hurt) {
        this.hurt = hurt;
    }
}


package com.neusoft.day11.classMember;

/**
 * @author Eric Lee
 * @date 2020/7/25 11:44
 */
public class Armour {
    //
    String name;
    int protect; // 防御值

    public Armour(String name, int protect) {
        this.name = name;
        this.protect = protect;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getProtect() {
        return protect;
    }

    public void setProtect(int protect) {
        this.protect = protect;
    }
}


package com.neusoft.day11.classMember;

/**
 * @author Eric Lee
 * @date 2020/7/25 11:42
 */
public class Role {
    int id ;
    int blood ; // 生命值
    String name;
    // 添加武器属性
    Weapon wp;
    // 盔甲
    Armour ar;

    public Weapon getWp() {
        return wp;
    }

    public void setWp(Weapon wp) {
        this.wp = wp;
    }

    public Armour getAr() {
        return ar;
    }

    public void setAr(Armour ar) {
        this.ar = ar;
    }


    // 攻击
    public void attack(){
        System.out.println("使用"+ wp.getName() + "， 造成了" + wp.getHurt()+"点伤害");

    }

    // 防御
    public void  wear(){
        // 增加防御
        this.blood += ar.getProtect();
        System.out.println("穿上了" + ar.getName()+", 生命值增加了" + ar.getProtect());


    }



}


package com.neusoft.day11.classMember;

/**
 * @author Eric Lee
 * @date 2020/7/25 11:42
 */
public class Role {
    int id ;
    int blood ; // 生命值
    String name;
    // 添加武器属性
    Weapon wp;
    // 盔甲
    Armour ar;

    public Weapon getWp() {
        return wp;
    }

    public void setWp(Weapon wp) {
        this.wp = wp;
    }

    public Armour getAr() {
        return ar;
    }

    public void setAr(Armour ar) {
        this.ar = ar;
    }


    // 攻击
    public void attack(){
        System.out.println("使用"+ wp.getName() + "， 造成了" + wp.getHurt()+"点伤害");

    }

    // 防御
    public void  wear(){
        // 增加防御
        this.blood += ar.getProtect();
        System.out.println("穿上了" + ar.getName()+", 生命值增加了" + ar.getProtect());


    }

}
类作为成员变量， 对它进行赋值操作， 实际上， 是赋给他该类的对象

接口作为成员变量

public interface FaShuSkill {
    public abstract void faShuAttack();
}

public class WangZheRole {
    FaShuSkill fs;

    public void setFaShuSkill(FaShuSkill fs) {
        this.fs = fs;
    }
    // 法术攻击
    public void faShuSkillAttack(){
        System.out.println("发动法术攻击");
        fs.faShuAttack();
        System.out.println("攻击完毕");
    }
}

package com.neusoft.day11.classMember;

/**
 * @author Eric Lee
 * @date 2020/7/25 14:26
 */
public class WangZheTest {
    public static void main(String[] args) {
        WangZheRole role = new WangZheRole();

//        role.setName("zhangsan")
        role.setFaShuSkill(new FaShuSkill() {
            @Override
            public void faShuAttack() {
                System.out.println("安琪拉的羊肉串");
            }
        });
        // 法术攻击
        role.faShuSkillAttack();
        // 更换技能
        role.setFaShuSkill(new FaShuSkill() {
            @Override
            public void faShuAttack() {
                System.out.println("大乔叫你回家");
            }
        });
        // 法术攻击
        role.faShuSkillAttack();



    }
}

接口作为成员变量， 对它进行赋值操作， 实际上赋给他该接口的子类的对象

接口作为方法的参数和返回值类型

当接口作为方法的参数和返回值类型，传递和返回的都是他的子类对象
原来我们这样做

public class Demo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        ArrayList<Integer> doubleNumList = getDoubleNum(list);
        System.out.println(doubleNumList);

    }


    public static  ArrayList<Integer> getDoubleNum(ArrayList<Integer> list){
        ArrayList<Integer> doubleList = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i) % 2 == 0)
                doubleList.add(list.get(i));
        }
        return doubleList;
    }
}

接口作为方法的参数和返回值类型, 我们这样做

package com.neusoft.day11.interfaceDemo;

import java.util.ArrayList;
import java.util.List;

/**
 * @author Eric Lee
 * @date 2020/7/25 14:37
 */
public class Demo1 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        List<Integer> doubleNumList = getDoubleNum(list);
        System.out.println(doubleNumList);

    }


    public static  List<Integer> getDoubleNum(List<Integer> list){
        List<Integer> doubleList = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i) % 2 == 0)
                doubleList.add(list.get(i));
        }
        return doubleList;
    }
}

接口作为参数时， 他传递的是子类对象
接口作为返回值类型是， 他返回的是子类对象

相关文章

  • day11final、权限、内部类

    final final 不可改变，可以用于修饰类、方法、变量 类 ：被修饰的类，不能被继承 方法：被修饰的方法， ...

  • 内部类---Thinking in Java读书笔记系列(一)

    内部类的访问权限: 内部类就是定义在类内部的类.普通的类,访问权限有两种:public和默认的包访问权限.内部类的...

  • 内部类

    成员内部类 局部内部类（定义在方法内和定义在作用域内的类） 匿名内部类

  • Thinking In Java读书笔记-内部类

    [toc] 内部类 内部类可以有外围类所有元素的访问权限 比方说迭代器就是通过内部类的方式实现的 内部类得到外部类...

  • 内部类及其作用，静态内部类和非静态内部类的区别

    1.什么是内部类？ 内部类就是定义在一个类的内部，包含内部类的类就称为外部类，内部类可以声明访问权限，如publi...

  • Java 内部类

    内部类包括成员内部类、方法内部类、*静态内部类、匿名内部类*。 内部类的作用 由于内部类的实现和外部类没有关系，内...

  • java se 四种权限修饰符

    类的权限修饰符的使用规则1、外部类：public/(default)2、成员内部类：四个都能用3、局部内部类：什么都不用

  • Java学习——内部类

    内部类 一，成员内部类（包括静态内部类和非静态内部类） 非静态内部类可以直接访问外部类的成员，反之则不行 非静态内...

  • Java 内部类、静态内部类、方法内部类（未完待续）

    内部类 什么是内部类？内部类其实就是在一个类中创建的类。内部类有四种： 成员内部类 静态内部类 局部内部类 匿名内...

  • java 内部类

    一般有四种内部类的使用方式： 嵌套的内部类 方法内的内部类 静态内部类 匿名内部类 什么时候用内部类： 有时候明显...

网友评论

      本文标题：day11final、权限、内部类

      本文链接：https://www.haomeiwen.com/subject/vkhplktx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|day11final、权限、内部类|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！