JAVA之从入门到放弃（三）

2022-11-27  本文已影响0人  蛋上有皱纹
访问修饰符 (访问控制)

作用：控制当前代码的可见范围 目的：保护程序的合法性，安全性，健壮性
属性的封装：属性私有化，方法公开化

public(公开的)：任意位置都可以访问，权限最大
protected(保护的)：一般存在父级代码中，当前类/同包类/子类 可见
默认的：默认访问修饰符是不建议的 当前类/同包类 可见
private(私有的)：权限最小 当前类 可见
final

final代表的是最终的意思，可以修饰类、属性、方法

//final测试演示类
public class FinalDemo {
    private final int a; //final修饰符变量要么在声明时初始化
    FinalDemo() {
        a = 10; //final修饰符变量要么在构造方法中初始化
    }

    void show() {
//        a = 10; //final修饰符变量不能再普通方法中初始化
    }
}

final class Aoo { //final修饰的类不可以被继承
    public final void test() { //final修饰的方法不可以被重写

    }
}

class Boo/* extends Aoo*/ {
//    public void test() {   //不可以重写
//
//    }
}
static (静态变量)
静态资源：

如：
每个学生的杯子属于对象吗？属于，属于个人的
饮水机属于对象吗？不属于，但可以被对象共享。----->静态资源

方法区特点：一个类应该有一份.class字节码文件，当类被首次使用时，该类的.class 字节码文件会被加载到方法区中，加载且只加载一次

JVM分配空间：栈区，堆区，方法区
栈区：放局部变量的区域
堆区：放对象的区域
方法区：用来加载.class字节码文件（类中的静态变量，类中的方法（构造方法/静态方法/普通方法））

class Coo {
    public int a;//实例变量：属于对象的,有多个对象有多少份
    public static int b;//静态变量：属于类的,只有一份被所有对象共享
    Coo() {
        a++;
        b++;
    }
    void show() {//普通方法
        this.a = 0;//访问类实例成员默认有个this的写法
        Coo.b = 0;//访问类静态成员默认有个类名点的写法
        System.out.println("实例变量a的值:" + a + ",静态变量b的值:" + b);
    }
    static void show2() {//静态方法中:无法使用this
//        this.a = 1;  普通实例成员不可直接在static修饰的方法中调用
//           this.show();普通方法不可直接在static修饰的方法中调用
        Coo.b = 1;//静态方法可直接访问静态的内容.
    }
}
static (静态方法)

用static修饰的方法称之为静态方法

class Coo {
    private int a; //实例变量：属于对象的,有多少个对象有多少份
    public static int b; //静态变量：属于类的，有且只有一份被所有对象共享
    Coo() {
        a ++;
        b ++;
    }

    void show() {   //普通方法
        this.a = 0; //访问类实例成员默认有个this
        Coo.b = 0;  //访问静态成员默认有个类名点的写法
        System.out.println("实例变量a的值：" + a + "静态变量b的值：" + b);
    }
    static void show2() { // 静态方法中：无法使用this
//        a = 0;        普通实例成员不可以在static修饰的方法中调用
//        this.show();  普通方法不可以在static修饰的方法中调用
        Coo.b = 2;     //静态方法可以直接访问类的静态内容
    }
}
static (静态代码块)
/*测试静态代码块的类*/
public class StaticDemo2 {
    public static void main(String[] args) {
//        Doo doo1 = new Doo();
//        Doo doo2 = new Doo();
        Doo doo3 = new Doo();
//        Doo.a = 2; //访问类中的静态成员 也叫使用类，如果是首次使用则会加载
    }
}

class Doo {
    public static int a = 2;
    Doo() { //创建多少个对象 则执行多少次   构造方法的作用：创建对象时可以为对象初始化数据
        System.out.println("Doo类的构造方法执行了");
    }
    static {    //静态代码块:类被首次加载时执行，且只加载一次  静态代码块的作用：一般用于为静态成员初始化使用的语法
        System.out.println("Doo类被加载了。。我执行了。。");
    }
}
常量

用static final修饰的属性则是常量，常量结合static和final的特性
特性：常量可以通过类名打点形式访问，不能二次修改且声明时需要初始化
常量命名：要求纯大写，多个单词之间用下划线隔开
常量的适用性：当有一份数据，确定后几乎不会发生改变的，也不会频繁修改得，那么可以作为常量来表示，常量一般也可以用于表示一些固定状态的使用

/*常量的使用演示类*/
public class StaticFinalDemo {
    public static void main(String[] args) {
//        System.out.println(Eoo.a);
//        Eoo e = new Eoo();
//        System.out.println(e.b);

        /*1.先将Eoo类字节码文件加载到方法区
        * 2.输出静态变量a的值*/
        System.out.println(Eoo.a);

       /*在编译期间使用常量，本质上就是将常量的值进行访问(不会执行static代码块)*/
        System.out.println(Eoo.C);
    }
}

class Eoo {
    public static int a;            //静态变量
    public final int b = 1;         //final修饰的变量
    public static final int C = 100;//常量
    static {
        System.out.println("静态代码块执行了、、、、");
    }
}
抽象方法（半成品）
抽象类

抽象方法的意义：
1）遵循面向对象设计原则，如果父类中提供的方法子类都不能用是不是需要重写？
如果做成普通方法，子类是不是可以重写 也可以不重写？
目的：为了约束子类必须重写，不重写代码报错
2）子类都重写了，父类的抽象方法还有存在的意义吗？
目的：父类中存在的抽象方法的意义是为了向上造型，调用父类执行子类

内部类 (应用率不高)

内部类：类中套个类，类结构中的类称之为内部类

class Aoo { //外部类
      class Boo { //内部类
      }
}
匿名内部类 (应用率高)

匿名内部类：没有名字的内部类称之为匿名内部类
适用性：当一个子类仅仅只是为了实现重写父类中的某个功能时，而其他地方根本不用该子类，那么我们可以使用匿名内部类的方式，目的：让面相实现开发，而不关心语法，更关心的是逻辑如何实现

        //1.创建一个匿名内部类，花括号就是匿名子类的类体
        //2.运行时创建的子类对象赋值给sub
        //3.通过sub调用重写的show方法
        SupperDemo sub = new SupperDemo() {
            @Override
            void show() {
//                sub.a = 20; // 匿名内部类访问外部类成员 会自动修饰为final， a不可二次修改
                System.out.println(a); //可以访问
                System.out.println("匿名内部类重写了父类中的show方法");
            }
        };
        sub.show();

问：内部类有没有独立的.class字节码文件?
答：无论是成员内部类还是匿名内部类都有.class字节码文件

数组扩容

Arrays.copy

        int[] array = {}; //为array数组创建了一个数组对象， 数组长度为0
        int a = 100;
        //copyOf: 1.要扩容的数组对象 2.基于原数组长度的基础上 + 或 - 要扩容或缩容的容量
        array = Arrays.copyOf(array, array.length + 1);
        System.out.println("扩容后" + array.length);
        array[array.length - 1] = a;
        System.out.println("存数后" + Arrays.toString(array));

System.arrayCopy

        int[] a = {50, 60, 70, 80};
        int[] b = {0, 0, 0, 0};
        /*arrayCopy的5个参数
        * 1.要拷贝的原数组
        * 2.从原数组哪个下标开始拷贝
        * 3.要拷贝到的目标数组
        * 4.从目标数组哪个下标开始装载
        * 5.拷贝的数量， 目标数组长度 - 目标数组装载的下标
        （注意：拷贝的数量不能超过目标数组容纳的范围）*/
        System.arraycopy(a, 1, b, 1, a.length - 1);
接口

定义：接口是一组行为的规范，接口并不关心多个类之间是否是一种的关系，只关心这些类的行为是否一样，一个类可以实现多个接口，一般一个接口只代表一个行为，不要做大而全的接口，要做小而精的接口

抽象类和接口的区别
多态

在程序中多态指的是，一个父类下的行为子类有不同的实现

向上造型：引用类型中的自动类型转换

能够向上造型的语法：实现继承关系 声明父 new子 | 实现关系 声明接口 new 实现类

向下转型：引用类型中的强制类型转换

引用类型中能否强制转换成功，具体参考以下两个条件

上一篇下一篇

猜你喜欢

热点阅读