达内java学习day11＋day12

最新推荐文章于 2024-05-31 10:46:10 发布

从毕业开始学习

最新推荐文章于 2024-05-31 10:46:10 发布

阅读量90

点赞数 1

分类专栏：达内study 文章标签： java 学习 jvm

本文链接：https://blog.csdn.net/qq_52483391/article/details/125987783

版权

达内study 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

更更更！

1.static final常量：应用率高

必须声明的同时初始化

由类名打点访问，不能被改变

建议：常量所有字母都大写，多个单词用_分隔

编译器在编译时会将常量直接替换为具体的数，效率高

何时用：数据永远不变，并且经常使用

2.抽象方法:

由abstract修饰

只有方法的定义，没有具体的实现（连{}都没有）

（1）设计规则：

将派生类所共有的属性和行为，抽到超类方法中……抽共性

若派生类的行为（代码实现）都一样，设计为普通方法

若派生类的行为（实现代码）都不一样，设计为抽象方法

（2）抽象方法/抽象类：

抽象方法存在的意义是什么？

保证当发生向上造型时，通过超类的引用能点出那个方法……

既然抽象方法的意义是保证能点出来，那为什么不设计普通方法呢？

设计为普通方法，意味着派生类可以重写也可以不重写，但是设计为抽象方法，则可以强制派生类必须重写……达到强制派生类重写，统一的目的

3.抽象类:

由abstract修饰

包含抽象方法的类必须是抽象类

抽象类不能被实例化（new对象）

抽象类是需要被继承的，派生类：

重写抽象方法……变不完整为完整

也声明为抽象类……一般不这么用

抽象类的意义：

封装共有的属性和行为……代码复用

为所有派生类提供统一的类型……向上造型（代码复用）

可能包含抽象方法，为所有派生类提供统一的入口（向上造型后能点出来），同时可以达到强制必须重写的目的（相当于定制了一个标准）

1.成员内部类：应用率不高

1.1：类中套类，外面的称为外部类，里面的类称为内部类

1.2：内部类通常只服务于外部类，对外不具备可见性

1.3：内部类对象通常在外部类中创建

1.4：内部类中可以直接访问外部类的成员（包括私有的）

内部类中有一个隐式的引用，指向了创建它的外部类对象…外部类名。this…

public class InnerClassDemo {
      public static void main(String[] args) {
        Mama m = new Mama();
        //Baby b = new Baby(); //编译错误，内部类对外不具备可见性
      }
    }

    class Mama{ //外部类
      private String name;
      void create(){
        Baby b = new Baby();
      }
      class Baby{ //内部类
        void showName(){
            System.out.println(name); //简便写法
            System.out.println(Mama.this.name); //完整写法
            //System.out.println(this.name); //编译错误，this指代当前Baby对象
        }
      }
    }

2.匿名内部类：…………大大简化了代码的操作

2.1若想创建一个类（派生类）的对象，并且对象只被创建一次，此时可以设计为匿名内部类

2.2在匿名内部类中不能修饰外面局部变量的值，因为该变量在此处会默认为final的

2.3内部类有独立的.class文件

    public class NstInnerClassDemo {
      public static void main(String[] args) {
        //1)系统自动创建了Aoo的一个派生类，但是没有名字
        //2)为该派生类创建了一个对象，名为o1
        //  ---new Aoo(){}是在创建Aoo的派生类的对象
        //3)大括号中的为派生类的类体
        Aoo o1 = new Aoo(){
        };

        //1)系统自动创建了Aoo的一个派生类，但是没有名字
        //2)为该派生类创建了一个对象，名为o2
        //3)大括号中的为派生类的类体
        Aoo o2 = new Aoo(){
        };


        //1)系统自动创建了Boo的一个派生类，但是没有名字
        //2)为该派生类创建了一个对象，名为o3
        //3)大括号中的为派生类的类体
        Boo o3 = new Boo(){
            void show(){
                System.out.println("showshow");
            }
        };
        o3.show();


        int num = 5;
        num = 55;
        Boo o4 = new Boo(){
            void show(){
                System.out.println("showshow");
                //num = 66; //编译错误，匿名内部类中不能修改外面局部变量的值，
                            //因为在此处该变量会默认为final的
            }
        };

      }
  }

  abstract class Boo{
    abstract void show();
  }

  abstract class Aoo{
  }