Day11-fianl、权限、内部类、引用类型

最新推荐文章于 2024-07-15 22:27:12 发布

lyb92nlf

最新推荐文章于 2024-07-15 22:27:12 发布

阅读量108

点赞数

分类专栏： Java基础文章标签： java

本文链接：https://blog.csdn.net/qq_41733080/article/details/103931139

版权

Java基础专栏收录该内容

11 篇文章 0 订阅

订阅专栏

第一章 final关键字

1.1 概述

final：不可改变，可以修饰类、方法和变量
- 类：被修饰的类，不能被继承
- 方法：被修饰的方法，不能被重写
- 变量：被修饰的变量，不能被冲洗赋值

1.2 使用方式

final class 类名
如String类、Math类、Scanner类
修饰符 final 返回值类型方法名(参数列表)
修饰变量
1. 局部变量–基本类型
  只能赋值一次，不能再被更改
```
for (int i = 0; i < 10; i++) 
	 final int c = i;
	 System.out.println(c);	 
}
```
此时编译不会报错，每次循环都是一个新的常量c。
1. 局部变量–引用类型
  只能指向一个对象，地址不能再更改。但不影响成员变量的重新赋值。
2. 成员变量
  被final修饰的常量名称，一般有书写规范，所有的字母都大写。

第二章权限修饰符

	public	protected	default(空的)	private
	公共的	受保护的	默认的	私有的
同一个类中	√	√	√	√
同一个包中（子类与无关类）	√	√	√
不同包的子类	√	√
不同包的无关类	√

建议：

成员变量用private，方法用public
无修饰符的效果和default一致

第三章内部类

3.1 成员内部类

定义在类中方法外的类。通常使用在一个事物内部还有其他事物的情况。

class 外部类 {
	class 内部类{	

	} 
}

访问特点

内部类可以访问外部类的成员，包括私有成员。
外部类要访问内部类的成员必须实例化。

package cn.itcast.day11.demo01;

public class Person {
    private boolean live = true;

    class Heart{
        public void jump(){
            if(live){
                System.out.println("还活着");
            }else{
                System.out.println("awsl");
            }
        }
    }
    public boolean isLive() {
        return live;
    }

    public void setLive(boolean live) {
        this.live = live;
    }
}

package cn.itcast.day11.demo01;

public class Demo01InnerClass {
    public static void main(String[] args) {
        Person p1 = new Person();
        Person.Heart heart = p1.new Heart();
        heart.jump();//还活着

        p1.setLive(false);
        heart.jump();//awsl
    }
}

内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。

比如，Person$Heart.class

3.2 匿名内部类

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

前提

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

格式

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

例子

public class InnerDemo2 {
	public static void main(String[] args) 
	 	/*
	 	1.等号右边:定义并创建该接口的子类对象 
	 	2.等号左边:是多态,接口类型引用指向子类对象
	 	*/ 				 	
		FlyAble f = new FlyAble(){
			public void fly() {
				System.out.println("我飞了~~~");			
			}
		};
		// 将f传递给showFly方法中 showFly(f);
	}
	public static void showFly(FlyAble f) {
	 	f.fly();
	} 
}

第四章引用类型用法总结

4.1 class作为成员变量

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

package cn.itcast.day11.demo01.demo02;

public class Armour {
    private String name;
    private int 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 cn.itcast.day11.demo01.demo02;

public class Weapon {
    private String name;
    private int 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 cn.itcast.day11.demo01.demo02;

public class Role {
    private int id;
    private int blood;
    private String name;

    Weapon w;
    Armour a;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getBlood() {
        return blood;
    }

    public void setBlood(int blood) {
        this.blood = blood;
    }

    public String getName() {
        return name;
    }

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

    public Weapon getW() {
        return w;
    }

    public void setW(Weapon w) {
        this.w = w;
    }

    public Armour getA() {
        return a;
    }

    public void setA(Armour a) {
        this.a = a;
    }


    public void attack(){
        System.out.println(w.getName()+"造成"+w.getHurt()+"点伤害");
    }

    public void wear(){
        this.blood += a.getProtect();
        System.out.println(a.getName()+"生命值增加"+a.getProtect());
    }
}

package cn.itcast.day11.demo01.demo02;

public class Demo01MiniGame {
    public static void main(String[] args) {
        Weapon w = new Weapon();
        w.setName("小刀");
        w.setHurt(30);

        Armour a = new Armour();
        a.setName("皮衣");
        a.setProtect(10);

        Role r = new Role();
        r.setA(a);
        r.setW(w);

        r.attack();
        System.out.println("装备前" + r.getBlood());
        r.wear();
        System.out.println("装备后" + r.getBlood());
    }
}

4.2 interface作为成员变量

package cn.itcast.day11.demo01.demo03;

abstract class FaShuSkill {
    public abstract void fashuAttack();
}

package cn.itcast.day11.demo01.demo03;

public class Role {
    FaShuSkill fs;

    public void setFs(FaShuSkill fs) {
        this.fs = fs;
    }

    public void faShuSkillAttack(){
        System.out.print("发动攻击：");
        fs.fashuAttack();
        System.out.println("攻击结束");
    }
}

package cn.itcast.day11.demo01.demo03;

public class Demo01InterFaceVariable {
    public static void main(String[] args) {
        Role r = new Role();
        r.setFs(new FaShuSkill() {
            @Override
            public void fashuAttack() {
                System.out.println("红莲烈焰");
            }
        });
        r.faShuSkillAttack();
    }
}

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

4.3 interface作为方法参数和返回值类型

当接口作为方法的参数时,需要传递什么呢？当接口作为方法的返回值类型时，需要返回什么呢？对，其实都是它的子类对象。 ArrayList 类我们并不陌生，查看API我们发现，实际上，它是 java.util.List 接口的实现类。所以，当我们看见 List 接口作为参数或者返回值类型时，当然可以将 ArrayList 的对象进行传递或返回。

请观察如下方法：获取某集合中所有的偶数。

public static List<Integer> getEvenNum(List<Integer> list) {
        // 创建保存偶数的集合
        ArrayList<Integer> evenList = new ArrayList<>();
        // 遍历集合list,判断元素为偶数,就添加到evenList中
        for (int i = 0; i < list.size(); i++) {
            Integer integer = list.get(i);
            if (integer % 2 == 0) {
                evenList.add(integer);
            }
        }
        /*返回偶数集合 因为getEvenNum方法的返回值类型是List,而ArrayList是List的子类,
          因为getEvenNum方法的返回值类型是List,而ArrayList是List的子类, 所以evenList可以返回 
        */
        return evenList; 
    }

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