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"); } } 答案：父型参数
子类showpackage 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)重载