Java基础类的具体细节

Posted Ricky_0528

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java基础类的具体细节相关的知识,希望对你有一定的参考价值。

文章目录

1. final关键字

1.1 概念及四种用法

final关键字代表最终、不可改变的

常见四种用法:

  • 可以用来修饰一个类
  • 可以用来修饰一个方法
  • 还可以用来修饰一个局部变量
  • 还可以用来修饰一个成员变量

1.2 修饰一个类

当final关键字用来修饰一个类的时候,格式:

public final class 类名称 
    // ...

含义:当前这个类不能有任何的子类,但仍然可以有父类

注意事项:一个类如果是final的,那么其中所有的成员方法都无法进行覆盖重写(因为没有子类)

1.3 修饰一个方法

当final关键字用来修饰一个方法的时候,这个方法就是最终方法,也就是不能被覆盖重写,但是可以正常被子类继承使用

格式:

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

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

1.4 修饰局部变量

一旦使用final来修饰局部变量,那么这个变量就不能进行更改,即“一次赋值,终身不变”

可以先声明再赋值,只需要保证仅有有唯一一次赋值操作即可

不可变:

  • 对于基本类型来说,不可变说的是变量当中的数据不可改变
  • 对于引用类型来说,不可变说的是变量当中的地址值不可改变,但里面的内容可变(即通过方法改变)

1.5 修饰成员变量

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

注意事项:

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

1.6 配合static使用

表示全局的不允许被修改的内容,常用于一些配置信息

2. 权限

2.1 四种权限修饰符

public > protected > (default) > private

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

2.2 不同权限的访问能力

publicprotecteddefault(空的)private
同一类中✔️✔️✔️✔️
同一包中(子类与无关类)✔️✔️✔️
不同包的子类✔️✔️
不同包中的无关类✔️

形象化记忆:

  • 同一个类:我自己
  • 同一个包:我领居
  • 不同包子类:我儿子
  • 不同包非子类:陌生人

使用权限建议

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

3. 内部类

3.1 概述

将一个类A定义在另一个类B里面,里面的那个类A就称为内部类,B则称为外部类

分类:

  • 成员内部类
  • 局部内部类(包含匿名内部类)

内部类隐藏在外部类之内,更好的实现了信息隐藏

3.2 成员内部类

①定义

格式:

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

注意事项:

  • 内用外,随意访问
  • 外用内,需要内部类对象
package ricky.base.day11.demo01;
public class Body  // 外部类
    public class Heart  // 成员内部类
        public void methodHeart () 
            System.out.println("内部类的方法");
            System.out.println("我叫" + name); // 正确访问
        
    
    private String name;
    public void methodBody() 
        System.out.println("外部类的方法");
    
    public String getName() 
        return name;
    
    public void setName(String name) 
        this.name = name;
    

内部类生成的 .class 文件中间以 $ 符号标识,故在给 .java 文件命名时不建议使用 $ 符号

②使用

间接方式:在外部类的方法当中,使用内部类,然后main只是调用外部类的方法

外部类对象.获取方法

直接方式——公式:

外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
外部类名称.内部类名称 对象名 = 外部类对象.new 内部类名称();

Demo01InnerClass

package ricky.base.day11.demo01;

public class Demo01InnerClass 
    public static void main(String[] args) 
        Body body = new Body();
        body.setName("Ricky");
        // 间接方式
        body.methodBody();
        System.out.println("============");
        // 直接方式
        Body.Heart heart = new Body().new Heart();
        heart.methodHeart();
    


Body

package ricky.base.day11.demo01;

public class Body  // 外部类
    public class Heart  // 成员内部类
        public void methodHeart () 
            System.out.println("内部类的方法");
            System.out.println("我叫" + name); // 正确访问
        
    
    private String name;
    public void methodBody() 
        System.out.println("外部类的方法");
        new Heart().methodHeart(); // 间接
    
    public String getName() 
        return name;
    
    public void setName(String name) 
        this.name = name;
    

③变量访问

如果出现了重名现象,那么访问外部类的成员变量格式为:外部类名称.this.外部类成员变量名

package ricky.base.day11.demo02;

public class Outer 
    int num = 10; // 外部类的成员变量
    public class Inner 
        int num = 20; // 内部类的成员变量
        public void methodInner() 
            int num = 30; // 内部方法的局部变量
            System.out.println(num); // 局部变量,就近原则
            System.out.println(this.num); // 内部类的成员变量
            System.out.println(Outer.this.num); // 外部类的成员变量
        
    

④注意事项
  • 内部类在外部使用时,无法直接实例化,需要借由外部类信息才能完成实例化
  • 内部类的访问修饰符可以任意,但是访问范围会受到影响
  • 内部类可以直接访问外部类的成员,如果出现同名属性,优先访问内部类中定义的
  • 可以使用 外部类.this.成员 的方式,访问外部类中的同名信息
  • 外部类访问内部类信息,需要通过内部类实例,无法直接访问
  • 内部类编译后.class文件命名:外部类$内部类.class

3.3 静态内部类

①定义

静态内部类对象可以不依赖于外部类对象直接创建

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

②使用
外部类名称.内部类名称 对象名 = new 外部类名称.内部类名称();
③注意事项
  • 静态内部类中,只能直接访问外部类的静态成员,如果需要调用非静态成员,可以通过对象实例:new 外部类.非静态成员
  • 静态内部类对象实例时,可以不依赖于外部类对象
  • 可以通过 外部类.内部类.静态成员 的方式,访问内部类中的静态成员
  • 当内部类属性与外部类属性同名时,默认直接调用内部类中的成员
  • 如果需要访问外部类中的静态属性,则可以通过 外部类.属性 的方式
  • 如果需要访问外部类中的非静态属性,则可以通过 new 外部类().属性 的方式

3.4 局部内部类(方法内部类)

①定义

如果一个类是定义在一个方法内部的,那么这就是一个局部的内部类

“局部”:只有当前所属的方法才能使用它,出了这个方法外面就不能用了,即需要在方法内部创建对象或者返回内部的方法调用

定义格式:

修饰符 class 外部类名称 
    修饰符 返回值类型 外部类方法名称(参数列表) 
        class 局部内部类名称 
            // ...
        
    

Outer

package ricky.base.day11.demo03;

public class Outer 
    public void methodOuter() 
        class Inner 
            int num = 10;
            public void methodInner() 
                System.out.println(num);
            
        
        Inner inner = new Inner();
        inner.methodInner();
    

DemoMain

package ricky.base.day11.demo03;

public class DemoMain 
    public static void main(String[] args) 
        Outer obj = new Outer();
        obj.methodOuter();
    

定义一个类的时候,权限修饰符规则:

  • 外部类:public / (default)
  • 成员内部类:public / protected / (default) / private
  • 局部内部类:什么都不能写
②注意事项
  • 定义在方法内部,作用范围也在方法内
  • 和方法内部成员使用规则一样,class前面不可以添加public、private、protected、static
  • 类中不能包含静态成员
  • 类中可以包含final、abstract修饰的成员
③局部内部类的final问题

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

注:从Java 8+开始,只要局部变量事实不变,那么final关键字可以省略(即是有效的final)

原因:

  • new出来的对象在堆内存当中
  • 局部变量是跟着方法走的,在栈内存当中
  • 方法运行结束之后,立刻出栈,局部变量就会立刻消失
  • 但是new出来的对象会在堆当中持续存在,直到垃圾回收才会消失,所以会一直需要访问那个局部变量,冲突

3.5 匿名内部类

①定义

如果接口的实现类(或者是父类的子类)只需要使用唯一的一次

那么这种情况下就可以省略掉该类的定义,而改为使用匿名内部类,即将类的定义与类的创建放到一起完成

定义格式:

接口名称 对象名 = new 接口名称() 
    // 覆盖重写了所有抽象方法

例一

MyInterface

package ricky.base.day11.demo04;

public interface MyInterface 
    void method(); // 匿名方法

DemoMain

package ricky.base.day11.demo04;

public class DemoMain 
    public static void main(String[] args) 
        MyInterface obj = new MyInterface() 
            @Override
            public void method() 
                System.out.println("匿名内部类覆盖重写了方法");
            
        ;
        obj.method();
    

例二

Person

package com.ricky.anonymous;

public abstract class Person 
	private String name;
	
	public Person() 
		
	

	public String getName() 
		return name;
	

	public void setName(String name) 
		this.name = name;
	
	
	public abstract void read();

PersonTest

package com.ricky.test;

import com.ricky.anonymous.Person;

public class PersonTest 

	public void getRead(Person person) 
		person.read();
	
	
	public static void main(String[] args) 
		// TODO Auto-generated method stub
		PersonTest test = new PersonTest();
		
		test.getRead(new Person() 
			@Override
			public void read() 
				// TODO Auto-generated method stub
				System.out.println("男生正在看书");
			
		);
	


3.8 匿名内部类的注意事项

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

  • new代表创建对象的动作
  • 接口名称就是匿名内部类需要实现哪个接口
  • … 这才是匿名内部类的内容

注意事项:

  • 匿名内部类没有类型名称、实例对象名称

  • 编译后的文件命名:外部类$数字.class

  • 无法使用public、private、protected、abstract、static修饰

  • 无法编写构造方法,可以添加构造代码块实现初始化

  • 不能出现静态成员

  • 匿名内部类可以实现接口也可以继承父类,但不可兼得

  • 匿名内部类在创建对象的时候,只能使用唯一一次

    如果希望多次创建对象,而且类的内容一样的话,那么就必须使用单独定义的实现类了

  • 匿名对象在调用方法的时候,只能使用唯一一次

    如果希望同一个对象调用多次方法,那么必须给对象起个名字

  • 匿名内部类是省略了实现类/子类名称,但是匿名对象是省略了对象名称,两者不是一回事!!!

4. 引用类型

4.1 class作为成员变量

武器类

class Weapon 
  String name; // 武器名称   
    int hurt; // 伤害值

盔甲类

class Armour 
   String name;// 装备名称  
    int protect;// 防御值 

角色类

class Role 
    int id;
    int blood;
    String name;
    // 添加武器属性
    Weapon wp;
    // 添加盔甲属性
    Armour ar;
    // 提供get/set方法
    public Weapon getWp() 
        return wp;
    
    public void setWeapon(Weapon wp) 
        this.wp = wp;
    
    public Armour getArmour() 
        return ar;
    
    public void setArmour(Armour ar) 
        this.ar = ar;
    
    // 攻击方法
    public void attack()
        System.out.println("使用"+ wp.getName() +", 造成"+wp.getHurt()+"点伤害"); 
    
    // 穿戴盔甲
    public void wear()
        // 增加防御,就是增加blood值
        this.blood += ar.getProtect();
        System.out.println("穿上"+ar.getName()+", 生命值增加"+ar.getProtect());
     

测试类

public class Test 
   public static void main(String[] args)   
     // 创建Weapon 对象     
       Weapon wp = new Weapon("屠龙刀" , 999999);        
       // 创建Armour 对象  
       Armour ar = new Armour("麒麟甲",10000);  
       // 创建Role 对象  
       Role r = new Role();        
       
       // 设置武器属性  
       r.setWeapon(wp);   
       // 设置盔甲属性      
       r.setArmour(ar);  
     
       // 攻击  
       r.attack();  
        // 穿戴盔甲
       r.wear();  
     

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

4.2 interface作为成员变量

接口

public interface FaShuSkill 
    public abstract void faShuAttack();

角色类

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

测试类

public class Test 
    public static void main(String[] args) 
        // 创建游戏角色
        Role role = new Role();
        // 设置角色法术技能
        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();
    

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

方法

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的子类, 
   所以evenList可以返回 
   */  
    return evenList;

方法调用

public class Test 
    public static void main(String[] args) 
        // 创建ArrayList集合,并添加数字
        ArrayListjava基础-反射(细节)

Java基础:枚举类的具体使用

《皇室战争》克隆法术卡组分享

Java_类的热替换

Java基础04 Java隐藏和封装类的继承多态

java基础 - 面试题