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基础 - 面试题