1:方法(掌握)

  1. (1)方法：就是完成特定功能的代码块。<br />  注意：在很多语言里面有函数的定义，而在Java中，函数被称为方法。<br />    (2)格式：<br />  修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {<br />      方法体语句;<br />      return 返回值;<br />  }<br />  修饰符：目前就用 public static<br />  参数分类：<br />      实参：实际参与运算的数据<br />      形参：方法上定义的，用于接收实际参数的变量<br />  方法体语句：就是完成功能的代码块<br />  return：结束方法<br />  返回值：就是功能的结果，由return带给调用者。<br />    (3)两个明确：<br />  返回值类型：结果的数据类型<br />  参数列表：参数的个数及对应的数据类型<br />    (4)方法调用<br />  A:有明确返回值的方法<br />      a:单独调用，没有意义<br />      b:输出调用，不是很好，因为我可能需要不结果进行进一步的操作。但是讲课一般我就用了。<br />      c:赋值调用，推荐方案<br />  B:void类型修饰的方法<br />      a:单独调用<br />    (5)案例：<br />  A:求和方案<br />  B:获取两个数中的较大值<br />  C:比较两个数据是否相同<br />  D:获取三个数中的最大值<br />  E:输出m行n列的星形<br />  F:输出nn乘法表<br />    (6)方法的注意事项<br /> A:方法不调用不执行<br />  B:方法之间是平级关系，不能嵌套定义<br />  C:方法定义的时候，参数是用，隔开的<br />  D:方法在调用的时候，不用在传递数据类型<br />  E:如果方法有明确的返回值类型，就必须有return语句返回。<br />    (7)方法重载<br />  在同一个类中，方法名相同，参数列表不同。与返回值无关。<br /> <br />  参数列表不同：<br />      参数的个数不同。<br />      参数的对应的数据类型不同。<br />    (8)方法重载案例<br />  不同的类型的多个同名方法的比较。

2:数组(掌握)

  1. (1)数组：存储同一种数据类型的多个元素的容器。<br />    (2)特点：每一个元素都有编号，从0开始，最大编号是长度-1。<br />          编号的专业叫法：索引<br />    (3)定义格式<br />  A:数据类型[] 数组名;<br />  B:数据类型 数组名[];<br /> <br />  推荐是用A方式，B方法就忘了吧。<br />  但是要能看懂<br />    (4)数组的初始化<br />  A:动态初始化<br />      只给长度，系统给出默认值<br />   <br />      举例：int[] arr = new int[3];<br />  B:静态初始化<br />      给出值，系统决定长度<br />   <br />      举例：int[] arr = new int[]{1,2,3};<br />      简化版：int[] arr = {1,2,3};<br />    (5)Java的内存分配<br />  A:栈 存储局部变量<br />  B:堆 存储所有new出来的<br />  C:方法区(面向对象部分详细讲解)<br />  D:本地方法区(系统相关)<br />  E:寄存器(CPU使用)<br /> <br />  注意：<br />      a:局部变量 在方法定义中或者方法声明上定义的变量。<br />      b:栈内存和堆内存的区别<br />    栈：数据使用完毕，就消失。<br />    堆：每一个new出来的东西都有地址<br />        每一个变量都有默认值<br />      byte,short,int,long 0<br />      float,double 0.0<br />      char '\u0000'<br />      boolean false<br />      引用类型 null<br />     数据使用完毕后，在垃圾回收器空闲的时候回收。

3:面向对象(掌握)

  1. (1)面向对象<br />  面向对象是基于面向过程的编程思想<br />    (2)面向对象的思想特点<br />  A:是一种更符合我们思考习惯的思想<br />  B:把复杂的事情简单化<br />  C:让我们从执行者变成了指挥者<br />  D:万事万物皆对象<br />    (3)把大象装进冰箱(理解)<br />  A:面向过程实现<br />  B:面向对象实现<br /> <br />  注意：如何让我们的操作更符合面向对象思想呢?<br />  A:有哪些类<br />  B:每个类有哪些成员<br />  C:类与类的关系<br />    (4)类与对象<br />  A:现实世界的事物<br />      属性    事物的基本描述<br />      行为    事物的功能<br />  B:Java语言中最基本的单位是类。所以，我们要用类来体现事物<br />  C:类<br />      成员变量    事物属性<br />      成员方法    事物行为<br />  D:类：是一组相关的属性和行为的集合。是一个抽象的概念。<br />    对象：是该类事物的具体存在，是一个具体的实例。(对象)<br />   <br />    举例：<br />      学生：类<br />      班长：对象<br />    (5)类的定义及使用<br />  A:类的定义<br />      成员变量    定义格式和以前一样，就是位置不同，在类中，方法外。<br />      成员方法    定义格式和以前一样，就是去掉了static。<br />  B:使用类的内容<br />      a:创建对象? 格式<br />    类名 对象名 =  new 类名();<br />      b:如何使用成员变量和成员方法呢<br />    对象名.成员变量<br />    对象名.成员方法()<br />    (6)案例：<br />  A:学生类的定义和使用<br />  B:手机类的定义和使用<br />    (7)内存图<br />  A:对象的内存图<br />    (8)Java程序的开发，设计<br />  A:开发：就是不断的创建对象，通过对象调用功能<br />  B:设计：就是管理和维护对象间的关系

4:成员变量和局部变量的区别(理解)

  1. (1)在类中的位置不同<br />  成员变量：类中方法外<br />  局部变量：方法定义中或者方法声明上<br />    (2)在内存中的位置不同<br />  成员变量：在堆中<br />  局部变量：在栈中<br />    (3)生命周期不同<br />  成员变量：随着对象的创建而存在，随着对象的消失而消失<br />  局部变量：随着方法的调用而存在，随着方法的调用完毕而消失<br />    (4)初始化值不同<br />  成员变量：有默认值<br />  局部变量：没有默认值，必须定义，赋值，然后才能使用<br />

5:类作为形式参数的问题?(理解)

  1. (1)如果你看到一个方法需要的参数是一个类名，就应该知道这里实际需要的是一个具体的对象。

6:匿名对象(理解)

  1. (1)没有名字的对象<br />    (2)应用场景<br />  A:调用方法，仅仅只调用一次的时候。<br />  b:可以作为实际参数传递。<br />

6:this关键字(掌握)

  1. (1)代表当前类的引用对象<br />  记住：哪个对象调用方法，该方法内部的this就代表那个对象<br />    (2)this的应用场景：<br />  A:解决了局部变量隐藏成员变量的问题

7:构造方法(掌握)

  1. (1)作用：用于对对象的数据进行初始化<br />    (2)格式：<br />  A:方法名和类名相同<br />  B:没有返回值类型，连void都不能有<br />  C:没有返回值<br />  思考题：构造方法中可不可以有return语句呢?<br />  可以。而是我们写成这个样子就OK了：return;<br />  其实，在任何的void类型的方法的最后你都可以写上：return;<br />    (3)构造方法的注意事项<br />  A:如果我们没写构造方法，系统将提供一个默认的无参构造方法<br />  B:如果我们给出了构造方法，系统将不再提供默认构造方法<br />      如果这个时候，我们要使用无参构造方法，就必须自己给出。<br />      推荐：永远手动自己给出无参构造方法。<br />    (4)给成员变量赋值的方式<br />  A:setXxx()<br />  B:带参构造方法<br />    (5)标准案例  <br />测试:  
  1. class StudentDemo {
  2.       public static void main(String[] args) {
  3.     //方式1
  4.     Student s1 = new Student();
  5.     s1.setName("张三");
  6.     s1.setAge(27);
  7.     System.out.println(s1.getName()+"---"+s1.getAge());
  9.     //方式2
  10.     Student s2 = new Student("李四",30);
  11.     System.out.println(s2.getName()+"---"+s2.getAge());
  12.       }
  13.   }

8:代码：Student s = new Student();做了哪些事情?(理解)

  1. (1)把Student.class文件加载到内存<br />    (2)在栈内存为s开辟空间<br />    (3)在堆内存为学生对象申请空间<br />    (4)给学生的成员变量进行默认初始化。null,0<br />    (5)给学生的成员变量进行显示初始化。张三,27<br />    (6)通过构造方法给成员变量进行初始化。李四,30<br />    (7)对象构造完毕，把地址赋值给s变量

9:static关键字(理解)

  1. (1)静态的意思：可以修饰成员变量和成员方法。<br />    (2)静态的特点：<br />  A:随着类的加载而加载<br />  B:优先于对象存在<br />  C:被类的所有对象共享<br />      这其实也是我们判断该不该使用静态的依据。<br />  D:可以通过类名调用<br />      既可以通过对象名调用，也可以通过类名调用，建议通过类名调用。<br />    (3)静态的内存图<br />  静态的内容在方法区的静态区<br />    (4)静态的注意事项；<br />  A:在静态方法中没有this对象<br />  B:静态只能访问静态(代码测试过)<br />    (5)静态变量和成员变量的区别<br />  A:所属不同<br />      静态变量：属于类，类变量<br />      成员变量：属于对象，对象变量，实例变量<br />  B:内存位置不同<br />      静态变量：方法区的静态区<br />      成员变量：堆内存<br />  C:生命周期不同<br />      静态变量：静态变量是随着类的加载而加载，随着类的消失而消失<br />      成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失<br />  D:调用不同<br />      静态变量：可以通过对象名调用，也可以通过类名调用<br />      成员变量：只能通过对象名调用<br />    (6)main方法是静态的<br />  public:权限最大<br />  static:不用创建对象调用<br />  void:返回值给jvm没有意义<br />  main:就是一个常见的名称。<br />  String[] args:可以接收数据，提供程序的灵活性<br />      格式：java MainDemo hello world java<br />      java MainDemo 10 20 30

10:private关键字(掌握)

  1. (1)私有的意义，可以修饰成员变量和成员方法<br />    (2)特点：<br />  被private修饰后的成员只能在本类中被访问<br />    (3)private的应用：<br />  以后再写一个类的时候：<br />      把所有的成员变量给private了<br />      提供对应的getXxx()/setXxx()方法<br />(4)private是封装的一种体现。

11:final关键字

final关键字可以用来修饰引用、方法和类。
(1)用来修饰一个引用
如果引用为基本数据类型，则该引用为常量，该值无法修改；
如果引用为引用数据类型，比如对象、数组，则该对象、数组本身可以修改，但指向该对象或数组的地址的引用不能修改。
如果引用时类的成员变量，则必须当场赋值，否则编译会报错。
(2):用来修饰一个方法
当使用final修饰方法时，这个方法将成为最终方法，无法被子类重写。但是，该方法仍然可以被继承。
(3):用来修饰类
当用final修改类时，该类成为最终类，无法被继承。简称为“断子绝孙类”。比如常用的String类就是最终类。

12:继承(掌握)

  1. (1)把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，<br />    这多个类就具备了这些内容。这个关系叫继承。<br />    (2)Java中如何表示继承呢?格式是什么呢?<br />  A:用关键字extends表示<br />  B:格式：<br />      class 子类名 extends 父类名 {}<br />    (3)继承的好处：<br />  A:提高了代码的复用性<br />  B:提高了代码的维护性<br />  C:让类与类产生了一个关系，是多态的前提<br />    (4)继承的弊端：<br />  A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。<br />      原则：低耦合，高内聚。<br />      耦合：类与类的关系<br />      内聚：自己完成某件事情的能力<br />  B:打破了封装性<br />    (5)Java中继承的特点<br />  A:Java中类只支持单继承<br />  B:Java中可以多层(重)继承(继承体系)<br />    (6)继承的注意事项：<br />  A:子类不能继承父类的私有成员<br />  B:子类不能继承父类的构造方法，但是可以通过super去访问<br />  C:不要为了部分功能而去继承<br />    (7)什么时候使用继承呢?<br />  A:继承体现的是：is a的关系。<br />    (8)Java继承中的成员关系<br />  A:成员变量<br />      a:子类的成员变量名称和父类中的成员变量名称不一样，这个太简单<br />      b:子类的成员变量名称和父类中的成员变量名称一样，这个怎么访问呢?<br />    子类的方法访问变量的查找顺序：<br />        在子类方法的局部范围找，有就使用。<br />        在子类的成员范围找，有就使用。<br />        在父类的成员范围找，有就使用。<br />        找不到，就报错。<br />  B:构造方法<br />      a:子类的构造方法默认会去访问父类的无参构造方法<br />    是为了子类访问父类数据的初始化<br />      b:父类中如果没有无参构造方法，怎么办?<br />    子类通过super去明确调用带参构造<br />    子类通过this调用本身的其他构造，但是一定会有一个去访问了父类的构造<br />    让父类提供无参构造<br />  C:成员方法<br />      a:子类的成员方法和父类中的成员方法名称不一样，这个太简单<br />      b:子类的成员方法和父类中的成员方法名称一样，这个怎么访问呢?<br />    通过子类对象访问一个方法的查找顺序：<br />        在子类中找，有就使用<br />        在父类中找，有就使用<br />        找不到，就报错<br />    (9)两个面试题：<br />  A:Override和Overload的区别?Overload是否可以改变返回值类型?<br />  B:this和super的区别和各自的作用?<br />    (10)数据初始化的面试题<br />  A:一个类的初始化过程<br />  B:子父类的构造执行过程<br />  C:分层初始化

13:封装(理解)

  1. (1)隐藏实现细节，提供公共的访问方式<br />    (2)好处：<br />A:隐藏实现细节，提供公共的访问方式<br />B:提高代码的复用性<br />C:提高代码的安全性<br />    (3)设计原则<br />把不想让外界知道的实现细节给隐藏起来，提供公共的访问方式<br />    (4)private是封装的一种体现。

14:多态(掌握)

  1. (1)同一个对象在不同时刻体现出来的不同状态。<br />    (2)多态的前提：<br />  A:有继承或者实现关系。<br />  B:有方法重写。<br />  C:有父类或者父接口引用指向子类对象。<br /> <br />  多态的分类：<br />      a:具体类多态<br />    class Fu {}<br />    class Zi extends Fu {}<br />   <br />    Fu f = new Zi();<br />      b:抽象类多态（常用）<br />    abstract class Fu {}<br />    class Zi extends Fu {}<br />   <br />    Fu f = new Zi();<br />      c:接口多态（经常用）<br />    interface Fu {}<br />    class Zi implements Fu {}<br />   <br />    Fu f = new Zi();<br />    (3)多态中的成员访问特点<br />  A:成员变量<br />      编译看左边（父类），运行看左边<br />  B:构造方法<br />      子类的构造都会默认访问父类构造<br />  C:成员方法<br />      编译看左边，运行看右边<br />  D:静态方法<br />      编译看左边，运行看左边<br />   <br />  为什么?<br />      因为成员方法有重写。<br />    (4)多态的好处：<br />  A:提高代码的维护性(继承体现)<br />  B:提高代码的扩展性(多态体现)<br />    (5)多态的弊端：<br />  父不能使用子的特有功能。<br /> <br />  现象：<br />      子可以当作父使用，父不能当作子使用。<br />    (6)多态中的转型<br />  A:向上转型<br />      从子到父<br />  B:向下转型<br />      从父到子<br />    (7)王五和王小五踢足球案例帮助大家理解多态<br />    (8)多态的练习<br />  A:猫狗案例

15:代码块(理解)

  1. (1)用{}括起来的代码。<br />    (2)分类：<br />  A:局部代码块<br />      用于限定变量的生命周期，及早释放，提高内存利用率。<br />  B:构造代码块<br />      把多个构造方法中相同的代码可以放到这里，每个构造方法执行前，首先执行构造代码块。<br />  C:静态代码块<br />      对类的数据进行初始化，仅仅只执行一次。<br />    (3)静态代码块,构造代码块,构造方法的顺序问题?<br />  静态代码块 > 构造代码块 > 构造方法

16:抽象类(掌握)

  1. (1)把多个共性的东西提取到一个类中，这是继承的做法。<br />    但是呢，这多个共性的东西，在有些时候，方法声明一样，但是没有方法体。<br />    也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。<br />    所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。<br />    而一个没有具体的方法体的方法是抽象的方法。<br />    在一个类中如果有抽象方法，该类必须定义为抽象类。<br />    (2)抽象类的特点<br />  A:抽象类和抽象方法必须用关键字abstract修饰<br />  B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类<br />  C:抽象类不能实例化<br />  D:抽象类的子类<br />      a:是一个抽象类。<br />      b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。<br />    (3)抽象类的成员特点：<br />  A:成员变量<br />      有变量，有常量<br />  B:构造方法<br />      有构造方法<br />  C:成员方法<br />      有抽象，有非抽象<br />    (4)抽象类的练习<br />  A:猫狗案例练习<br />    (5)抽象类的几个小问题<br />  A:抽象类有构造方法，不能实例化，那么构造方法有什么用?<br />      用于子类访问父类数据的初始化<br />  B:一个类如果没有抽象方法,却定义为了抽象类，有什么用?<br />      为了不让创建对象<br />  C:abstract不能和哪些关键字共存<br />      a:final    冲突<br />      b:private   冲突<br />      c:static     无意义

17:接口(掌握)

  1. (1)鸟和飞机案例 （都有飞行的功能）<br />              （2)门和防盗门案例（有开、关、报警alarm()功能）<br />    (2)接口的特点：<br />  A:接口用关键字interface修饰<br />      interface 接口名 {}<br />  B:类实现接口用implements修饰<br />      class 类名 implements 接口名 {}<br />  C:接口不能实例化<br />  D:接口的实现类<br />      a:是一个抽象类。<br />      b:是一个具体类，这个类必须重写接口中的所有抽象方法。<br />    (3)接口的成员特点：<br />  A:成员变量<br />      只能是常量<br />      默认修饰符：public static final<br />  B:构造方法<br />      没有构造方法<br />  C:成员方法<br />      只能是抽象的<br />      默认修饰符：public abstract<br />    (4)类与类,类与接口,接口与接口<br />  A:类与类<br />      继承关系，只能单继承，可以多层继承<br />  B:类与接口<br />      实现关系，可以单实现，也可以多实现。<br />      还可以在继承一个类的同时，实现多个接口<br />  C:接口与接口<br />      继承关系，可以单继承，也可以多继承<br />    (5)抽象类和接口的区别(自己补齐)?<br />  A:成员区别<br />      抽象类：有变量，有常量。<br />                      有构造方法<br />                      有抽象和非抽象成员方法。<br />      接口： 只有常量。默认修饰符：public static final<br />                   没有构造方法。<br />                   只能是抽象的。默认修饰符：public abstract。默认方法是在接口中的方法  签名前加上 default 关键字的实现方法。<br />  B:关系区别:<br />      类与类：<br />      类与接口：<br />      接口与接口：<br />  C:设计理念不同<br />      抽象类：is a，抽象类中定义的是共性功能。<br />      接口：like a，接口中定义的是扩展功能。<br />    (6)练习：<br />  A:老师和学生案例，加入抽烟功能

18: Object类(掌握)

  1. (1)Object是类层次结构的根类，所有的类都直接或者间接的继承自Object类。<br />    (2)Object类的构造方法有一个，并且是无参构造<br />  这其实就是理解当时我们说过，子类构造方法默认访问父类的构造是无参构造<br />    (3)要掌握的方法：<br />  A:toString()<br />      返回对象的字符串表示，默认是由类的全路径+'@'+哈希值的十六进制表示。<br />      这个表示其实是没有意义的，一般子类都会重写该方法。<br />      如何重写呢?过程我也讲解过了，基本上就是要求信息简单明了。<br />      但是最终还是自动生成。<br />  B:equals()<br />      比较两个对象是否相同。默认情况下，比较的是地址值是否相同。<br />      而比较地址值是没有意义的，所以，一般子类也会重写该方法。<br />      重写过程，我也详细的讲解和分析了。<br />      但是最终还是自动生成。<br />    (4)要了解的方法：<br />  A:hashCode() 返回对象的哈希值。不是实际地址值，可以理解为地址值（JVM的地址）。<br />  B:getClass() 返回对象的字节码文件对象，反射中我们会详细讲解  <br />  C:finalize() 用于垃圾回收，在不确定的时间<br />  D:clone() 可以实现对象的克隆，包括成员变量的数据复制，但是它和两个引用指向同一个对象是有区别的。实现Cloneable接口，重写clone() 方法<br />    (5)两个注意问题；<br />  A:直接输出一个对象名称，其实默认调用了该对象的toString()方法。<br />  B:面试题  <br />      ==和equals()的区别?<br />      A:==<br />    基本类型：比较的是值是否相同<br />    引用类型：比较的是地址值是否相同<br />      B:equals()<br />    只能比较引用类型。默认情况下，比较的是地址值是否相同。<br />    但是，我们可以根据自己的需要重写该方法。

19:异常(理解)

  1. (1)程序出现的不正常的情况。<br />    (2)异常的体系<br />  Throwable<br />      |--Error    严重问题，我们不处理。<br />      |--Exception<br />    |--RuntimeException    运行期异常，我们需要修正代码<br />    |--非RuntimeException 编译期异常，必须处理的，否则程序编译不通过<br />    (3)异常的处理：<br />  A:JVM的默认处理<br />      把异常的名称,原因,位置等信息输出在控制台，但是呢程序不能继续执行了。<br />  B:自己处理<br />      a:try...catch...finally<br />    自己编写处理代码,后面的程序可以继续执行<br />      b:throws<br />    把自己处理不了的，在方法上声明，告诉调用者，这里有问题<br />    (4)面试题<br />  A:编译期异常和运行期异常的区别?<br />      编译期异常 必须要处理的，否则编译不通过<br />      运行期异常 可以不处理，也可以处理<br />  B:throw和throws是的区别<br />      throw:<br />    在方法体中,后面跟的是异常对象名,并且只能是一个<br />    throw抛出的是一个异常对象，说明这里肯定有一个异常产生了<br />      throws:<br />    在方法声明上,后面跟的是异常的类名,可以是多个<br />    throws是声明方法有异常，是一种可能性，这个异常并不一定会产生<br />    (5)finally关键字及其面试题<br />  A:finally用于释放资源，它的代码永远会执行。特殊情况：在执行到finally之前jvm退出了（System.exit(-1)）<br />  B:面试题<br />      a:final,finally,finalize的区别?<br />      b:如果在catch里面有return,请问finally还执行吗?如果执行,在return前还是后<br />    会，前。<br />   <br />    实际上在中间。这个上课我们讲过<br />  C:异常处理的变形<br />      try...catch...finally<br />      try...catch...<br />      try...catch...catch...<br />      try...catch...catch...fianlly<br />      try...finally<br />    (6)自定义异常<br />  继承自Exception或者RuntimeException,只需要提供无参构造和一个带参构造即可<br />    (7)异常的注意实现<br />  A:父的方法有异常抛出,子的重写方法在抛出异常的时候必须要小于等于父的异常  <br />  B:父的方法没有异常抛出,子的重写方法不能有异常抛出<br />  C:父的方法抛出多个异常,子的重写方法必须比父少或者小