【java笔记】final关键字、权限修饰符、内部类

最新推荐文章于 2024-08-15 14:47:41 发布

码布里

最新推荐文章于 2024-08-15 14:47:41 发布

阅读量83

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/marcotsui/article/details/115366998

版权

/*
final关键字，表示最终的，不可变的
可以修饰：
1.类
2.方法
3.成员变量
4.局部变量
*/
final修饰一个类：

package demo01;
/*
final修饰一个类，不能有任何子类（俗称太监类）
final里的方法不可以覆盖重写
 */
public final class Demo02Class {
    public void method(){
        System.out.println("方法执行");
    }
}

final修饰成员方法：

package demo01;
/*
final修饰成员方法，表示这是最后一个方法，不可以对该方法覆盖重写

注意事项：abstract关键字必须覆盖重写，两者不能在一行使用。
 */
public class Fu {
    public final void method(){
        System.out.println("父类方法");
    }
}

final修饰局部变量：

package demo01;
/*
final关键字修饰局部变量
1.修饰基本数据类型
数据值不变
2.修饰引用数据类型
地址不变，地址的内容可以变
 */
public class Demo01Final {
    public static void main(String[] args) {
        final int num=20;
        //num=10;//错误写法

        Student stu1=new Student("关晓彤");
        System.out.println(stu1.getName());
        stu1=new Student("鹿晗");
        System.out.println(stu1.getName());
        
        final Student stu2=new Student("谢楠");
        System.out.println(stu2.getName());
        //stu2=new Student("吴京");//错误写法
        stu2.setName("吴京");
        System.out.println(stu2.getName());
    }

}

final修饰成员变量：

package demo01;
/*
final修饰成员变量
1.因为成员变量有默认值，所以要先赋值
2.可以在构造方法处赋值
3.也可以直接赋值
 */
public class Student {
    //private final String name="杨幂";//可以
    private  String name;

    public Student() {
        name="杨幂";
    }

    public Student(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

权限修饰符：

/*
权限修饰符：4种
              public >     protected>    (default)(不写） >   private
同一类          Yes            Yes             Yes              Yes
同包不同类      Yes            Yes             Yes              NO
不同包子类      Yes            Yes              NO               NO
不同包非子类    Yes             NO              NO               NO
 */

package demo02;

public class MyClass {
    public int num=10;
    public void method(){
        System.out.println(num);
    }
}

package demo02;

public class NewClass {
    public void newMethod(){
        System.out.println(new MyClass().num);
    }
}

package demo02.myson;

import demo02.MyClass;

public class MySon extends MyClass {

    public void methodSon(){
        System.out.println(super.num);
    }
}

package demo02.myson;

import demo02.MyClass;

public class Stranger {
    public void methodStr(){
        System.out.println(new MyClass().num);
    }
}

内部类：

package demo03;
/*
当出现包含和被包含的关系时，使用内部类
1.成员内部类
格式：
public class 类名称{
    public class 类名称{}
}
2.局部内部类


 */
public class Demo01 {
}


public class MyClass {
    public class Heart{
        //内部类方法
        public void beat(){
            System.out.println("咚咚咚");
            System.out.println("我是："+name);//内部可以调用外部
        }
    }
    private String name;
    //外部类方法
    public void method(){
        System.out.println("这是一个外部类方法");
    }
}

内部类的使用方法：

package demo03;
/*
当出现包含和被包含的关系时，使用内部类
1.成员内部类
格式：
public class 类名称{
    public class 类名称{}
}
使用方法：
（1）直接使用
    外部类.内部类 对象名=new 外部类（）.new 内部类（）；
（2）间接使用
    内部方法调用内部类
2.局部内部类


 */
public class Demo01 {
    public static void main(String[] args) {
        //间接使用
        MyClass my=new MyClass();
        my.method();

        //直接使用
        MyClass.Heart heart=new MyClass().new Heart();
        heart.beat();
    }
}

package demo03;

public class MyClass {
    public class Heart{
        //内部类方法
        public void beat(){
            System.out.println("咚咚咚");
            System.out.println("我是："+name);//内部可以调用外部
        }
    }
    private String name;
    //外部类方法
    public void method(){
        System.out.println("这是一个外部类方法");
        new Heart().beat();

    }
}

内部类的同名变量访问：

package demo01;

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);//外部类的成员变量
        }
    }
}

package demo01;

public class Demo01 {
    public static void main(String[] args) {
        Outer.Inner obj=new Outer().new Inner();
        obj.methodInner();
    }
}

局部内部类的定义：

package demo02;
/*
局部内部类：
格式：标识符 返回值类型 方法名称（参数列表）{
      class 类名称{。。。}
}
 */
public class Outer {
    public void  main(){
        class Method{

            public void Inner(){
                int num=10;
                System.out.println(num);
            }
        }
        Method method=new Method();
        method.Inner();
    }
}

package demo02;

public class Demo01 {
    public static void main(String[] args) {
        Outer out=new Outer();
        out.main();
    }
}
//10;

局部内部类的final问题：

public class Outer {
    public void  main(){
        int num=10;
        //num=20;//num不可以变
        class Method{
            public void Inner(){
                System.out.println(num);
            }
        }
        Method method=new Method();
        method.Inner();
    }
}

常量不可以改变的原因：生命周期
1.new出来的对象在堆内存
2.局部变量跟着方法走，在栈内存
3.方法运行完之后立刻出栈，局部变量立刻消失。
4.new出来的对象会在堆中一直存在，直到垃圾回收为止。

匿名内部类：

package demo03;

public interface MyInterface {
    void main();
}

package demo03;
/*
匿名内部类
格式：
接口名称  对象名=new 接口名称（）{
}；
 */
public class Demo01 {
    public static void main(String[] args) {
        MyInterface obj=new MyInterface() {
            @Override
            public void main() {
                System.out.println("匿名内部类实现了方法！");
            }

        };
        obj.main();
    }
}

类作为成员变量类型：

package demo04;

public class Demo01 {
    public static void main(String[] args) {
        Hero hero=new Hero();
        hero.setName("马丽");
        hero.setAge(24);
        Weapon weapon =new Weapon("大刀");
        hero.setWeapon(weapon);
        hero.attack();

    }
}

package demo04;

public class Hero {
    private String name;
    private Weapon weapon;
    private int age;

    public Hero() {
    }
    public void attack(){
        System.out.println("年龄为"+age+"的"+name+"用"+weapon.getCode()+"打别人");
    }
    public Hero(String name, Weapon weapon, int age) {
        this.name = name;
        this.weapon = weapon;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Weapon getWeapon() {
        return weapon;
    }

    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package demo04;

public class Weapon {
    private String code;

    public Weapon() {
    }

    public Weapon(String code) {
        this.code = code;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}

接口作为成员变量的类型：

package demo05;

public class Demo {
    public static void main(String[] args) {
        Hero hero=new Hero();
        hero.setName("沈腾");
        hero.setSkill(new SkillOk());
        hero.attack();
    }
}
/*
沈腾开始释放技能
biu~biu~biu
 */

package demo05;

public class Hero {
    private String name;
    private Skill skill;

    public Hero() {
    }

    public Hero(String name, Skill skill) {
        this.name = name;
        this.skill = skill;
    }

    public String getName() {
        return name;
    }

    public void attack(){
        System.out.println(name+"开始释放技能");
        skill.use();
    }

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

    public Skill getSkill() {
        return skill;
    }

    public void setSkill(Skill skill) {
        this.skill = skill;
    }
}

package demo05;

public interface Skill {
    public void use();
}

package demo05;

public class SkillOk implements Skill {
    @Override
    public void use() {
        System.out.println("biu~biu~biu");
    }
}

接口作为方法的参数：

package demo05;

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

/*
接口作为方法的参数

 */
public class DemoInterface {
    public static void main(String[] args) {
        //左接口，右实现类，多态写法
        List<String> list =new ArrayList<>();
        List<String> result=addNames(list);
        for (int i = 0; i < result.size(); i++) {
            System.out.println(result.get(i));
        }

    }
    public static List<String> addNames(List<String> list){
        list.add("马云");
        list.add("马化腾");
        list.add("马斯克");
        return list;

    }
}
/*
马云
马化腾
马斯克
 */

码布里

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【java笔记】final关键字、权限修饰符、内部类

/*final关键字，表示最终的，不可变的可以修饰：1.类2.方法3.成员变量4.局部变量*/final修饰一个类：package demo01;/*final修饰一个类，不能有任何子类（俗称太监类）final里的方法不可以覆盖重写 */public final class Demo02Class { public void method(){ System.out.println("方法执行"); }}final修饰成员方法：packa
复制链接

扫一扫