面向切面编程易混淆

package day01;
//引用类型画等号与null的演示
public class RefNullDemo {
    public static void main(String[] args) {
        Cell c = new Cell();
        Cell cc = c; //指向同一个对象
        c.row = 2;
        cc.row = 5;
        System.out.println(c.row); //5
        
        int a = 5;
        int b = a; //赋值
        b = 8;
        System.out.println(a); //5
        
        Cell c1 = new Cell();
        c1.row = 2;
        c1 = null; //空，没有指向任何对象
        c1.row = 2; //NullPointerException空指针异常
    }
}

答案：

5
5
Exception in thread "main" java.lang.NullPointerException
    at day01.RefNullDemo.main(RefNullDemo.java:19)

1.方法的签名:方法名+参数列表
2.方法的重载(Overload):
  1)发生在一个类中，方法名称相同，参数列表不一样
  2)编译器在编译时会自动根据签名来绑定调用不一样的方法
3.构造方法:构造函数、构造器、构建器
  1)经常用于给成员变量赋初值
  2)与类同名，没有返回值类型
  3)在建立对象时被自动调用
  4)若本身不写构造，则编译器默认提供一个无参构造
    若本身写了构造，则再也不默认提供
  5)构造方法能够重载
4.this:指代当前对象，哪一个对象调指的就是哪一个对象
       只能用在方法中，方法中访问成员变量以前默认有个this.
  this的用法:
    1)this.成员变量名------------访问成员变量
    2)this.方法名()--------------调用方法
    3)this()---------------------调用构造方法
5.引用类型数组:
  1)Cell[] cells = new Cell[4];
    cells[0] = new Cell(2,5);
    cells[1] = new Cell(2,6);
    cells[2] = new Cell(2,7);
    cells[3] = new Cell(3,6);
  2)Cell[] cells = new Cell[]{
      new Cell(2,5),
      new Cell(2,6),
      new Cell(2,7),
      new Cell(3,6)
    };
  3)int[][] arr = new int[3][];
    arr[0] = new int[2];
    arr[1] = new int[3];
    arr[2] = new int[2];
    //给arr中第2个元素中的第1个元素赋值为100
    arr[1][0] = 100;
  4)int[][] arr = new int[3][4]; //3行4列
    for(int i=0;i<arr.length;i++){
      for(int j=0;j<arr[i].length;j++){
        arr[i][j] = 100;
      }
    }

 

int[][] arr = new int[3][];
arr[0] = new int[2];
arr[1] = new int[3];
arr[2] = new int[2];
给arr中第2个元素中的第1个元素赋值为100
arr[1][0] = 100;

arr----------------int[][]
arr[0]-------------int[]
arr[0][0]----------int

 

 

 

 

arr包含3个元素
arr中的第1个元素又包含2个元素
arr中的第2个元素又包含3个元素
arr中的第3个元素又包含2个元素

//声明int型数组arr，包含3个元素
//每一个元素都是int型，默认值为0
int   [] arr   = new int[3];

//声明Cell型数组cells，包含4个元素
//每一个元素都是Cell型，默认值为null
Cell  [] cells = new Cell[4];

//声明int[]型数组arr，包含3个元素
//每一个元素都是int[]型，默认值为null
int[] [] arr   = new int[3][];

1.内存管理:由JVM来管理
  1)堆:
    1.1)存储全部new出来的对象(包括成员变量)
    1.2)没有任何引用指向的对象就是垃圾，
        垃圾回收器(GC)不定时到内存中清扫垃圾，
        回收过程是透明的(看不到的)，并不必定发现垃圾就立刻回收，
        调用System.gc()建议虚拟机尽快调度gc来回收垃圾
    1.3)内存泄漏:再也不使用的内存没有被及时的回收
                 建议:对象再也不使用时及时将引用设置为null
    1.4)成员变量的生命周期:
          建立对象时存在堆中，对象被垃圾回收器回收时一并消失
  2)栈:
    2.1)存储正在调用的方法中的全部局部变量(包括参数)
    2.2)调用方法时会为该方法在栈中分配一块对应的栈帧，
        栈帧中包含方法中的全部局部变量(包括参数)，
        方法调用结束时，栈帧被消除，局部变量随之消失
    2.3)局部变量的生命周期:
          调用方法时存在栈中，方法结束栈帧被清除时一并消失
  3)方法区:
    3.1)存储.class字节码文件(包括方法)
    3.2)方法只有一份，经过this来区分具体的对象
2.继承:
  1)做用:代码的复用
  2)经过extends来实现继承
  3)父类/基类:全部子类所共有的属性和行为
    子类/派生类:子类所特有的属性的行为
  4)子类继承父类后，子类具备: 子类的+父类的
  5)一个父类能够有多个子类，
    一个子类只能继承一个父类-----单一继承
  6)继承具备传递性
  7)java规定:构造子类以前必须先构造父类
    子类构造方法中若没有调用父类的构造方法，
    则默认super()调父类的无参构造，
    若子类构造方法中调用了父类的构造方法，则再也不默认提供
    super()调父类构造必须位于子类构造方法的第一句
3.super:指代当前对象的父类对象
  super的用法:
   1)super.成员变量名----------访问父类的成员变量
   2)super.方法名()------------调用父类的方法
   3)super()-------------------调用父类的构造方法
4.向上造型:
  1)父类型的引用指向子类的对象
  2)能点出来什么，看引用的类型

1)继承要符合is a的关系
2)问:子类能够继承父类的构造方法吗?
  答:不能，由于父类的构造方法是被子类调用的

1.方法的重写(Overrid):
  1)发生在父子类中，方法名相同，参数列表相同，方法体不一样
  2)重写方法被调用时，看对象的类型
2.重写与重载的区别:常见面试题
  1)重写(Override):
    1.1)发生在父子类中，方法名相同，参数列表相同，方法体不一样
    1.2)遵循"运行期"绑定，根据对象的类型来调用方法
  2)重载(Overload):
    2.1)发生在一个类中，方法名相同，参数列表不一样，方法体不一样
    2.2)遵循"编译期"绑定，根据引用的类型来绑定方法

5.static:静态的
  1)静态变量:
    1.1)由static修饰
    1.2)属于类的，存在方法区中，只有一份
    1.3)经常经过类名点来访问
    1.4)什么时候用:全部对象共享的数据(图片、音频、视频...)
  2)静态方法:
    2.1)由static修饰
    2.2)属于类的，存在方法区中，只有一份
    2.3)经常经过类名点来访问
    2.4)静态方法没有隐式的this传递，
        因此在静态方法中不能直接访问实例成员
    2.5)什么时候用:方法的操做仅与参数相关而与对象无关 ？？？？
  3)静态块:
    3.1)由static修饰
    3.2)属于类的，在类被加载期间自动执行，
        因类只被加载一次，因此静态块也只执行一次
    3.3)什么时候用:经常用于初始化静态资源(图片、音频、视频等)

封装
1.保护数据---------私有数据
2.保护程序的逻辑---公开方法
数据私有化，行为公开化

package oo.day04;
//重写与重载的演示
public class OverrideOverloadDemo {
    public static void main(String[] args) {
        Goo goo = new Goo();
        Eoo o = new Foo(); //向上造型
        goo.test(o); //重载看引用
    }
}

class Goo{
    void test(Eoo o){
        System.out.println("父型参数");
        o.show(); //重写看对象
    }
    void test(Foo o){
        System.out.println("子型参数");
        o.show();
    }
}

class Eoo{
    void show(){
        System.out.println("父类show");
    }
}
class Foo extends Eoo{
    void show(){
        System.out.println("子类show");
    }
}
答案：

父型参数
子类show
 

package oo.day04;
//static的演示
public class StaticDemo {
    public static void main(String[] args) {
        Loo o1 = new Loo();
        o1.show();
        Loo o2 = new Loo();
        o2.show();
        System.out.println(Loo.b); //2，建议经过类名来访问
        System.out.println(o1.b);  //2，不建议对象来访问
        
        Moo.test();
        
        Noo o3 = new Noo();
        Noo o4 = new Noo();
        
    }
}

class Noo{ //演示静态块
    Noo(){
        System.out.println("构造方法");
    }
    static{
        System.out.println("静态块");
    }
}

class Moo{ //演示静态方法
    int a;
    static int b;
    void show(){
        System.out.println(a);
        System.out.println(b);
    }
    static void test(){
        //编译错误，静态方法没有隐式this，
        //没有this意味着没有对象，
        //而a必须得经过对象来访问，
        //System.out.println(a);
        System.out.println(b);
    }
}

class Loo{ //演示静态变量
    int a;
    static int b;
    Loo(){
        a++;
        b++;
    }
    void show(){
        System.out.println("a="+a);
        System.out.println("b="+b);
    }
}

答案：

a=1
b=1
a=1
b=2
2
2
0
静态块
构造方法
构造方法

 

1.static final常量:
  1)必须声明同时初始化
  2)经过类名点访问，不能被改变
  3)建议:常量名全部字母都大写，多个单词之间用_链接
  4)编译器在编译时会将常量自动替换为具体的值，效率高
2.抽象方法:
  1)由abstract修饰
  2)只有方法的定义，没有方法的具体实现(连大括号都没有)
3.抽象类:
  1)由abstract修饰
  2)包含抽象方法的类必须是抽象类
    不包含抽象方法的类也能够声明为抽象类----我乐意
  3)抽象类不能被实例化
  4)抽象类都是须要被继承的，子类:
    4.1)重写抽象类中的全部抽象方法----建议
    4.2)也声明为抽象类----------------不建议
  5)抽象类的意义:
    5.1)封装子类共有的属性和行为，实现代码复用
    5.2)为全部子类提供了一种统一的类型--向上造型
    5.3)能够包含抽象方法，为全部子类提供了一个统一的入口，
        子类能够有不一样的实现，但方法的定义是一致的
4.接口:
  1)是一个标准、规范------制定方
    遵照了这个标准就能干某件事------------API以后
  2)是一个数据类型(引用类型)
  3)是由interface定义的
  4)只能包含常量和抽象方法
  5)接口不能被实例化
  6)接口是须要被实现的，实现类(遵照方):
      必须重写接口中的全部抽象方法
  7)一个类能够实现多个接口，用逗号隔开
    若又继承又实现时，应先继承后实现
  8)接口能够继承接口
1.多态:
  1)多态的意义:
    1.1)同一类型的引用指向不一样的对象时，有不一样的实现
        --------行为的多态: cut()、run()、study()
    1.2)同一个对象被造型为不一样的类型时，有不一样的功能
        --------对象的多态: 我、水、你
  2)向上造型:
    2.1)父类型的引用指向子类的对象
    2.2)能造型为的类型有: 父类+所实现的接口
    2.3)能点出来什么，看引用的类型
  3)强制类型转换，能成功的条件只有两种:
    3.1)引用所指向的对象，就是该类型
    3.2)引用所指向的对象，实现了该接口
  4)强转时若不符合如上两个条件，则发生ClassCastExcetion类型转换异常，
    因此建议在强转以前先经过instanceof来判断引用指向的对象是不是该类型
2.成员内部类: 单独应用的概率很少
  1)类中套类，外面的称为外部类，里面的称为内部类
  2)内部类一般只服务于外部类，对外不具有可见性
  3)内部类对象一般是在外部类中建立
  4)内部类中能够直接访问外部类的成员(包括私有的)
    内部类中有个隐式的引用指向了建立它的外部类对象
      eg:外部类名.this
3.匿名内部类:
  1)若想建立一个类(子类)的对象，而且对象只被建立一个，
    此时该类没必要命名，称之为匿名内部类
  2)匿名内部类中访问外部的变量，该变量必须是final的

4.面向对象的三大特征:   1)封装:     1.1)类:封装的是对象的属性和行为     1.2)方法:封装的是具体的业务逻辑功能实现     1.3)访问控制修饰符:封装的是具体的访问权限   2)继承:     2.1)做用:代码的复用     2.2)父类/基类:全部子类所共有的属性和行为         子类/派生类:子类所特有的属性和行为     2.3)子类继承父类后，子类具备:父+子     2.4)单一继承、传递性   3)多态:     3.1)意义、向上造型、强制类型转换、instanceof     3.2)多态的表现形式:         3.2.1)重写         3.2.2)重载