day11final、权限、内部类

2020-07-25 本文已影响0人 __method__

final

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

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

使用

修饰类
格式如下：

final class 类名 {
}

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

修饰方法
格式：

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

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

修饰变量

局部变量--基本类型
基本类型的局部变量，被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

局部变量--引用类型
引用类型的局部变量被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);
}
}

成员变量
成员变量涉及到初始化问题，初始化有两种，只能选一个

显示初始化

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 内部类型（）；

匿名内部类

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

定义子类
重写接口中所有的方法
创建子类对象
调用重写后的方法
我们的目的是调用方法，那能否简化一下呢？将四个步骤合为一步呢？
匿名内部类就可以实现
前提匿名内部类必须继承一个父类或者实现一个父接口
格式

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

使用

权限修饰符

内部类

访问特点

匿名内部类

引用类型用法总结

class作为成员变量

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

接口作为成员变量

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

猜你喜欢

热点阅读

day11final、权限、内部类

final

使用

权限修饰符

内部类

访问特点

匿名内部类

引用类型用法总结

class作为成员变量

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

接口作为成员变量

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

猜你喜欢

热点阅读

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