黑马笔记总结(一)

03.04_Java语言基础(位异或运算符的特点及面试题)(掌握)
* 位异或运算符的特点

* ^的特点：一个数据对另一个数据位异或两次，该数本身不变。

• B:面试题：
  
  • 请自己实现两个整数变量的交换

03.05_Java语言基础(位运算符的基本用法2及面试题)(了解)

• A:案例演示 >>,>>>,<<的用法:
  
  • <<:左移 左边最高位丢弃，右边补齐0
  • >>:右移 最高位是0，左边补齐0;最高为是1，左边补齐1
  • >>>:无符号右移 无论最高位是0还是1，左边补齐0
  • 最有效率的算出2 * 8的结果

03.19_Java语言基础(选择结构switch语句的格式及其解释)(掌握)

• C:面试题
  
  • byte可以作为switch的表达式吗?
  • long可以作为switch的表达式吗?
  • String可以作为switch的表达式吗?

03.21_Java语言基础(选择结构switch语句的注意事项)(掌握)

• A:案例演示
  
  • a:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
  • b:default可以省略吗?
    
    • 可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
    • 特殊情况：
      
      • case就可以把值固定。
      • A,B,C,D
  • c:break可以省略吗?
    
    • 最后一个可以省略,其他最好不要省略
    • 会出现一个现象：case穿透。
    • 最终我们建议不要省略
  • d:default一定要在最后吗?
    
    • 不是，可以在任意位置。但是建议在最后。
  • e:switch语句的结束条件
    
    • a:遇到break就结束了
    • b:执行到switch的右大括号就结束了

04.17_Java语言基础(控制调整语句练习)

• A:练习题

• for(int x=1; x<=10; x++) {
      if(x%3==0) {
          //在此处填写代码
      }
      System.out.println(“Java基础班”);
  }
  
  我想在控制台输出2次:“Java基础班“
  我想在控制台输出7次:“Java基础班“
  我想在控制台输出13次:“Java基础班“
  

05.18_Java语言基础(二维数组练习1遍历)(掌握)

• A:案例演示

  • 需求：二维数组遍历

  • 外循环控制的是二维数组的长度，其实就是一维数组的个数。

  • 内循环控制的是一维数组的长度。

    int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
    
    for (int i = 0;i < arr.length ;i++ ) {          //获取到每个二维数组中的一维数组
        for (int j = 0;j < arr[i].length ;j++ ) {   //获取每个一维数组中的元素
            System.out.print(arr[i][j] + " ");
        }
    
        System.out.println();
    }
    

06.10_面向对象(成员变量和局部变量的区别)(掌握)

• A:在类中的位置不同
  
  • 成员变量：在类中方法外
  • 局部变量：在方法定义中或者方法声明上
• B:在内存中的位置不同
  
  • 成员变量：在堆内存(成员变量属于对象,对象进堆内存)
  • 局部变量：在栈内存(局部变量属于方法,方法进栈内存)
• C:生命周期不同
  
  • 成员变量：随着对象的创建而存在，随着对象的消失而消失
  • 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

• D:初始化值不同

  • 成员变量：有默认初始化值
  • 局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

• 注意事项：

  • 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
  • 基本数据类型变量包括哪些:byte,short,int,long,float,double,boolean,char
  • 引用数据类型变量包括哪些:数组,类,接口,枚举

06.12_面向对象(匿名对象的概述和应用)(掌握)

• B:匿名对象应用场景
  
  • a:调用方法，仅仅只调用一次的时候。
    
    • 那么，这种匿名调用有什么好处吗?
      
      • 节省代码
    • 注意：调用多次的时候，不适合。匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
  • b:匿名对象可以作为实际参数传递

07.06_面向对象(创建一个对象的步骤)(掌握)

• A:画图演示
  
  • Student s = new Student();
  • 1,Student.class加载进内存
  • 2,声明一个Student类型引用s
  • 3,在堆内存创建对象,
  • 4,给对象中属性默认初始化值
  • 5,属性进行显示初始化
  • 6,构造方法进栈,对对象中的属性赋值,构造方法弹栈
  • 7,将对象的地址值赋值给s

07.10_面向对象(static关键字的特点)(掌握)

• A:static关键字的特点
  
  • a:随着类的加载而加载
  • b:优先于对象存在
  • c:被类的所有对象共享
  • d:可以通过类名调用
    
    • 其实它本身也可以通过对象名调用。
    • 推荐使用类名调用。
    • 静态修饰的内容一般我们称其为：与类相关的，类成员

07.11_面向对象(static的注意事项)(掌握)

• A:static的注意事项
  
  • a:在静态方法中是没有this关键字的
    
    • 如何理解呢?
      
      • 静态是随着类的加载而加载，this是随着对象的创建而存在。
      • 静态比对象先存在。
  • b:静态方法只能访问静态的成员变量和静态的成员方法
    
    • 静态方法：
      
      • 成员变量：只能访问静态变量
      • 成员方法：只能访问静态成员方法
    • 非静态方法：
      
      • 成员变量：可以是静态的，也可以是非静态的
      • 成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
    • 简单记：
      
      • 静态只能访问静态。

07.12_面向对象(静态变量和成员变量的区别)(掌握)

• 静态变量也叫类变量 成员变量也叫对象变量
• A:所属不同
  
  • 静态变量属于类，所以也称为为类变量
  • 成员变量属于对象，所以也称为实例变量(对象变量)
• B:内存中位置不同
  
  • 静态变量存储于方法区的静态区
  • 成员变量存储于堆内存
• C:内存出现时间不同
  
  • 静态变量随着类的加载而加载，随着类的消失而消失
  • 成员变量随着对象的创建而存在，随着对象的消失而消失
• D:调用不同
  
  • 静态变量可以通过类名调用，也可以通过对象调用
  • 成员变量只能通过对 象名调用

07.13_面向对象(main方法的格式详细解释)(了解)

• A:格式
  
  • public static void main(String[] args) {}
• B:针对格式的解释
  
  • public 被jvm调用，访问权限足够大。
  • static 被jvm调用，不用创建对象，直接类名访问
  • void被jvm调用，不需要给jvm返回值
  • main 一个通用的名称，虽然不是关键字，但是被jvm识别
  • String[] args 以前用于接收键盘录入的

08.01_面向对象(代码块的概述和分类)(了解)(面试的时候会问,开发不用或者很少用)

• A:代码块概述
  
  • 在Java中，使用{}括起来的代码被称为代码块。
• B:代码块分类
  
  • 根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。
• C:常见代码块的应用
  
  • a:局部代码块
    
    • 在方法中出现；限定变量生命周期，及早释放，提高内存利用率
  • b:构造代码块 (初始化块)
    
    • 在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
  • c:静态代码块
    
    • 在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。
    • 一般用于加载驱动

08.04_面向对象(继承的好处和弊端)(掌握)

• A:继承的好处
  
  • a:提高了代码的复用性
  • b:提高了代码的维护性
  • c:让类与类之间产生了关系，是多态的前提

• B:继承的弊端

  • 类的耦合性增强了。

  • 开发的原则：高内聚，低耦合。

  • 耦合：类与类的关系
  • 内聚：就是自己完成某件事情的能力

08.06_面向对象(继承的注意事项和什么时候使用继承)(掌握)

• A:继承的注意事项
  
  • a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
  • b:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。
  • c:不要为了部分功能而去继承
• B:什么时候使用继承
  
  • 继承其实体现的是一种关系：”is a”。
    Person
    Student
    Teacher

08.08_面向对象(this和super的区别和应用)(掌握)

• A:this和super都代表什么
  
  • this:代表当前对象的引用,谁来调用我,我就代表谁
  • super:代表当前对象父类的引用
• B:this和super的使用区别
  
  • a:调用成员变量
    
    • this.成员变量 调用本类的成员变量,也可以调用父类的成员变量
    • super.成员变量 调用父类的成员变量
  • b:调用构造方法
    
    • this(…) 调用本类的构造方法
    • super(…) 调用父类的构造方法
  • c:调用成员方法
    
    • this.成员方法 调用本类的成员方法,也可以调用父类的方法
    • super.成员方法 调用父类的成员方法

08.09_面向对象(继承中构造方法的关系)(掌握)

• A:案例演示
  
  • 子类中所有的构造方法默认都会访问父类中空参数的构造方法
• B:为什么呢?
  
  • 因为子类会继承父类中的数据，可能还会使用父类的数据。
  • 所以，子类初始化之前，一定要先完成父类数据的初始化。
  • 其实：
    
    • 每一个构造方法的第一条语句默认都是：super() Object类最顶层的父类。

08.14_面向对象(方法重写的注意事项)(掌握)

• A:方法重写注意事项
  
  • a:父类中私有方法不能被重写
    
    • 因为父类私有方法子类根本就无法继承
  • b:子类重写父类方法时，访问权限不能更低
    
    • 最好就一致
  • c:父类静态方法，子类也必须通过静态方法进行重写
    
    • 其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解(静态只能覆盖静态)
  • 子类重写父类方法的时候，最好声明一模一样。

08.15_面向对象(方法重写的面试题)(掌握)

• A:方法重写的面试题

  • Override和Overload的区别?Overload能改变返回值类型吗?
  • overload可以改变返回值类型,只看参数列表

  • 方法重写：子类中出现了和父类中方法声明一模一样的方法。与返回值类型有关,返回值是一致(或者是子父类)的

  • 方法重载：本类中出现的方法名一样，参数列表不同的方法。与返回值类型无关。

  • 子类对象调用方法的时候：

    • 先找子类本身，再找父类。

08.19_面向对象(final关键字修饰类,方法以及变量的特点)(掌握)

• A:final概述
• B:final修饰特点
  
  • 修饰类，类不能被继承
  • 修饰变量，变量就变成了常量，只能被赋值一次
  • 修饰方法，方法不能被重写

09.01_面向对象(多态的概述及其代码体现)
B:多态前提
a:要有继承关系。
b:要有方法重写。
c:要有父类引用指向子类对象。

09.07_面向对象(多态的好处和弊端)
A:多态的好处
a:提高了代码的维护性(继承保证)
b:提高了代码的扩展性(由多态保证)

多态的好处
可以当作形式参数,可以接收任意子类对象
C:多态的弊端
不能使用子类的特有属性和行为。

09.09_面向对象(抽象类的概述及其特点)
B:抽象类特点
a:抽象类和抽象方法必须用abstract关键字修饰
abstract class 类名 {}
public abstract void eat();
b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口
c:抽象类不能实例化那么，抽象类如何实例化呢?
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
d:抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法

09.10_面向对象(抽象类的成员特点)
A:抽象类的成员特点
a:成员变量：既可以是变量，也可以是常量。abstract是否可以修饰成员变量?不能修饰成员变量
b:构造方法：有。用于子类访问父类数据的初始化。
c:成员方法：既可以是抽象的，也可以是非抽象的。
C:抽象类的成员方法特性：
a:抽象方法 强制要求子类做的事情。
b:非抽象方法 子类继承的事情，提高代码复用性。

09.15_面向对象(抽象类中的面试题)
A:面试题1
一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
可以
这么做目的只有一个,就是不让其他类创建本类对象,交给子类完成

09.17_面向对象(接口的成员特点)
A:接口成员特点
成员变量；只能是常量，并且是静态的并公共的。 * 默认修饰符：public static final * 建议：自己手动给出。
构造方法：接口没有构造方法。
成员方法：只能是抽象方法。 * 默认修饰符：public abstract * 建议：自己手动给出。

09.19_面向对象(抽象类和接口的区别)
A:成员区别

抽象类：
成员变量：可以变量，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象
接口：
成员变量：只可以常量
成员方法：只可以抽象
C:设计理念区别
抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。

10.03_面向对象(带包的类编译和运行)(掌握)

• A:如何编译运行带包的类
  
  • a:javac编译的时候带上-d即可
    
    • javac -d . HelloWorld.java
  • b:通过java命令执行。
    
    • java 包名.HellWord

10.08_面向对象(内部类概述和访问特点)(了解)

• A:内部类概述
• B:内部类访问特点
  
  • a:内部类可以直接访问外部类的成员，包括私有。
  • b:外部类要访问内部类的成员，必须创建对象。
  • 外部类名.内部类名 对象名 = 外部类对象.内部类对象;

10.10_面向对象(静态成员内部类)(了解)

• static
• B:成员内部类被静态修饰后的访问方式是:
  
  • 外部类名.内部类名 对象名 = 外部类名.内部类对象;

10.12_面向对象(局部内部类访问局部变量的问题)(掌握)

• A:案例演示
  
  • 局部内部类访问局部变量必须用final修饰
  • 局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
    因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用但是jdk1.8取消了这个事情,所以我认为这是个bug

11.05_Java开发工具(Eclipse中内容辅助键的使用)(掌握)

• A:Alt+/ 起提示作用
• B:main+alt+/,syso+alt+/,给出其他提示
• C:补充输出语句,选中需要输出的部分,alt+/选择最后一项即可
• C:定义自己的alt + /
  
  • windows–perference-Java-Editor-Templates–New

11.06_Java开发工具(Eclipse中快捷键的使用)(掌握)

• A:新建 ctrl + n
• B:格式化 ctrl+shift+f
• C:导入包 ctrl+shift+o
• D:注释 ctrl+/,ctrl+shift+/,ctrl+shift+\
• E:代码上下移动 选中代码alt+上/下箭头
• F:查看源码 选中类名(F3或者Ctrl+鼠标点击)
• G:查找具体的类 ctrl + shift + t
• H:查找具体类的具体方法 ctrl + o
• I:给建议 ctrl+1,根据右边生成左边的数据类型,生成方法
• J:删除代码 ctrl + d
• K:抽取方法alt + shift + m
• L:改名alt + shift + r

11.07_Java开发工具(Eclipse中如何提高开发效率)(掌握)

• alt + shift + s
• A:自动生成构造方法
• B:自动生成get/set方法

11.16_常见对象(Object类的hashCode()方法)(了解)

• A:案例演示
  
  • public int hashCode()
  • a:返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
  • b:不同对象的，hashCode()一般来说不会相同。但是，同一个对象的hashCode()值肯定相同。

11.17_常见对象(Object类的getClass()方法)(在反射的时候掌握)

• A:案例演示
  
  • public final Class getClass()
  • a:返回此 Object 的运行时类。
  • b:可以通过Class类中的一个方法，获取对象的真实类的全名称。
    
    • public String getName()

11.20_常见对象(==号和equals方法的区别)(掌握)

• ==是一个比较运算符号,既可以比较基本数据类型,也可以比较引用数据类型,基本数据类型比较的是值,引用数据类型比较的是地址值
• equals方法是一个方法,只能比较引用数据类型,所有的对象都会继承Object类中的方法,如果没有重写Object类中的equals方法,equals方法和==号比较引用数据类型无区别,重写后的equals方法比较的是对象中的属性

13.03_常见对象(StringBuffer的添加功能)

• A:StringBuffer的添加功能
  
  • public StringBuffer append(String str):
    
    • 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
  • public StringBuffer insert(int offset,String str):
    
    • 在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
• A:StringBuffer的删除功能
  
  • public StringBuffer deleteCharAt(int index):
    
    • 删除指定位置的字符，并返回本身
  • public StringBuffer delete(int start,int end):
    
    • 删除从指定位置开始指定位置结束的内容，并返回本身
• A:StringBuffer的替换功能
  
  • public StringBuffer replace(int start,int end,String str):
    
    • 从start开始到end用str替换
• B:StringBuffer的反转功能
  
  • public StringBuffer reverse():
    
    • 字符串反转
• A:StringBuffer的截取功能
  
  • public String substring(int start):
    
    • 从指定位置截取到末尾
  • public String substring(int start,int end):
    
    • 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
• B:注意事项
  
  • 注意:返回值类型不再是StringBuffer本身

13.12_常见对象(数组高级冒泡排序原理图解)

冒泡排序
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处

13.14_常见对象(数组高级选择排序原理图解)

• 选择排序
• 从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

13.21_常见对象(String和int类型的相互转换)

• A:int – String
  
  • a:和”“进行拼接
  • b:public static String valueOf(int i)
  • c:int – Integer – String(Integer类的toString方法())
  • d:public static String toString(int i)(Integer类的静态方法)
• B:String – int
  
  • a:String – Integer – int
  • public static int parseInt(String s)

13.22_常见对象(JDK5的新特性自动装箱和拆箱)

• A:JDK5的新特性
  
  • 自动装箱：把基本类型转换为包装类类型
  • 自动拆箱：把包装类类型转换为基本类型
  • Integer ii = 100;
  • ii += 200;