Java

 

标识符

关键字

Java基础数据类型（四类八种，类型(大小)：字节字符型：byte(1)、char(2)，整型：short(2)、int(4)、long(8)，浮点型：float(4)、double(8)，逻辑型：boolean(1)）

运算符

表达式和语句

分支

循环

方法

变量的作用域

递归调用

 

 

如何用命令提示符打jar包？

1、打开命令提示符，切换到你想要打成jar包目录的上一级

2、输入jar -cvf xxx.jar *.*，回车即可 //格式解释：jar -cvf +想打的jar包的名字 +想打的内容（*.*表示当前目录下的所有内容）

 

 

如何引入jar包？ 

直接把这个jar文件的路径设置进ClassPath下面就可以了。

 

 

 

包（package）： 

* 有一个约定俗成的命名方法，把你公司的域名倒过来写；如：com.bjsxt.java140。

* 没有指定 package 的类叫裸体类

* 编译出来的 class 文件必须位于正确的目录（与指定的package一致）下面，否则非同一目录下的另外的类访问不着。

* JDK1.4 以后该类的源码可能会产生影响，删除或转移到另外的目录下面，不要让源码位于 ClassPath 下面。

* class 文件的最上层包的父目录必须位于 ClassPath 下。

* 执行一个类需要写全包名。

* JDK 里面，在用的时候，就唯一个 java.lang 不需要引入，其他的，你要用它里面的类，必须引入。

 

 

变量： 

分为：基础数据类型变量 和 引用数据类型变量

基础数据类型变量：在内存中占一块内存，一经定义并赋值，名字和值都保存在这块内存中

引用数据类型变量：在内存中占两块内存，一经定义并赋值，其中一块内存保存真正的值（也就是new出来的具体的某个实例），另一块内存保存的是它定义的名字和它真正的值所在的内存地址（也就是对象的引用）

以后只要一谈到引用，脑子里就要想到：一小块内存指向一大块内存

 

 

 

 

变量的作用域（成员变量和局部变量）： 

* 注：Java 中不可定义 static 的局部变量，也就说没有静态局部变量。

* 成员变量和局部变量的重要区别：基础数据类型的成员变量如果你不给它初始化，Java会自动给它初始化，而基础数据类型的局部变量必须对它进行初始化才能使用；而引用数据类型的变量（无论成员变量还是局部变量）都需要实例化，否则都为 null ，你不实例化也能使用它，只不过使用时系统会抛出空指针异常（NullPointException）。

* static 的成员变量是属于整个类，被该类 new 出来的所有的对象共享；你不需要 new 出对象就可以直接可以用类名访问；而非 static 的成员变量是需要 new 出对象来才能进行访问。

* static 的成员变量的生命周期取决于该类，非 static 的成员变量的生命周期取决于该类 new 出来的对象，而局部变量的生命周期取决于它定义所在的那对花括号。

 

 

 

常量（用 final 修饰的变量）： 

* 常量也属于变量的范畴，它是一个特殊的变量，是一个不可以改变值的变量，故叫常量。

 

 

 

 

内存分区：

1、code segment 代码区 装代码

2、data segment 数据区 装静态变量和字符串常量

3、stack 栈 装局部变量

4、heap 堆 装new出来的东西

 

 

 

面向对象的设计思想：

当你考虑一个问题的时候不应该考虑第一步我要干嘛、第二步我要干嘛，要考虑什么呢？

1、首先要考虑，作为这个问题来说，在这个问题域里头应该有哪些个类哪些个对象，这是第一点；

2、然后再考虑这些个类这些对象每一种类每一种对象应该具有哪些个属性和方法，这是第二点；

3、再考虑类和类之间具备了什么样的关系。

 

 

 

类和对象的概念：

类：是具有共同特征的一类事物的抽象

对象：是这一类事物中具体的某个实例

1、对象用计算机语言对问题域中事物的描述，对象通过“属性（attribute）”和“方法（method）”来分别对应事物所具有的静态属性和动态属性。

2、类是用于描述同一类型的对象的一个抽象的概念，类中定义了这一类对象所应具有的静态和动态属性。

3、类可以看成一类对象的模板，对象可以看成该类的一个具体实例。

 

 

 

类（对象）之间的关系：

* 关联

* 继承

* 聚合

  ** 聚集

  ** 组合

* 多态

* 实现

 

 

继承关系（一般和特殊）： 

只要能说通：“XX是一种XX”。

如：足球运动员是一种球类运动员、篮球运动员是一种球类运动员、排球运动员是一种球类运动员、球类运动员是一种运动员、游泳运动员是一种运动员、射击运动员是一种运动员

 

 

聚合关系（整体和部分）： 

只要能说通：“XX是XX的一部分”。

如：队长是球队的一部分、队员是球队的一部分、胳膊是人的一部分、脑袋是人的一部分、身体是人的一部分。

聚合分的细一点还可以分为：聚集、组合

聚集：松聚合 队长，一个队长即可以是篮球队的队长也可以是足球队的队长

组合：紧聚合 脑袋，没听过一个脑袋即属于你也属于他吧

 

 

 

实现关系（父类和子类）： 

 

 

 

 

多态（也叫动态绑定，也叫迟绑定）： 

* 指的是在执行期间（而非编译期间）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

* 多态的存在有三个必要条件：

  ** 1、要有继承

  ** 2、要有重写

  ** 3、父类引用数据类型变量指向子类对象

  注：这三个条件一旦满足，当你调基类里被重写的方法的时候，实际当中 new 的是哪个子类对象，就调用子类对象里的方法。

 

 

 

访问控制： 

Java权限修饰符 public protected private 置于类的成员定义前，用来限定其他对象对该类对象成员的访问权限。

private：类内部

default：类内部、同一个包

protected：类内部、同一个包、子类

public：类内部、同一个包、子类、任何地方

* 对于 class 的权限修饰只可以用 public 和 default，public 类可以在任意地方被访问，default 类只可以被同一个包内部的类访问。

 

 

 

 

方法的重载与重写：

重载是同一个类下面，相同的方法名、不同的参数列表（个数或类型），与返回值类型无关。

重写是子类重新定义父类已有的方法，必须与父类方法具有相同的返回值类型、方法名、参数列表。

* 重写的方法不能使用比被重写方法更严格的访问权限，也就是说如果你重写的父类的方法的访问权限是 protected ，那么你子类重写的方法的访问权限就不能是 private 或 default，只能是 protected 或 public。

 

 

 

 

继承中的构造方法： 

* 子类构造的过程中必须调用其基类的构造方法。

* 子类可以在自己的构造方法中使用 super(argument_list) 调用基类的构造方法。

  ** 使用 this(argument_list) 调用本类另外的构造方法

  ** 如果调用 super，必须写在子类构造方法的第一行，说白了就是要先构造出父亲才会有儿子，故置第一行。

* 如果子类的构造方法中没有显示地调用基类的构造方法（也就说没写 super），则Java会默认调用基类无参的构造方法。

* 如果子类构造方法中既没有显示地调用基类的构造方法，而基类中又没有无参的构造方法，则编译出错。

 

 

 

Object 类之 equals 方法： 

Object类的equals方法的实现代码如下：

boolean equals(Object o){

    return this==o;

}

* Object 类中定义有：public boolean equals(Object obj) 方法，该方法提供定义对象是否“相等”的逻辑。

* Object 的 equals 方法定义为：x.equals(y) 当 x 和 y 是同一个对象的引用时返回 true，否则返回 false。

* J2SDK 提供的一些类，如 String、Date 等，重写了 Object 类的 equals 方法，调用这些类的 equals 方法，x.equals(y)，当 x 和 y 所引用的对象是同一类对象且属性的内容相等时（并不一定是相同对象），返回 true，否则返回 false。

* 可以根据需要在用户自定义类型中重写 equals 方法，这时你也应该将 hashCode 方法一并重写。

 

 

 

对象转型（casting）： 

* 一个父类的引用类型变量可以“指向”其子类的对象。

* 一个父类的引用类型变量不可以访问其子类对象新增加的属性（包括静态属性和动态属性）。

* 可以使用 引用类型变量 instanceof 类名 来判断该引用类型变量所“指向”的对象是否属于该类或该类的子类。

  ** instanceof：是某类或其子类的实例之一。

* 子类的对象可以当作父类的对象来使用，称作向上转型（upcasting），反之称为向下转型（downcasting）。

可扩展性（extensibility）：

* 一个典型的规则就是说，在增加新东西的同时尽量的不要去修改原来已经做好的东西，这个才叫可扩展性好。

 

 

 

抽象类（abstract）： 

* 用 abstract 修饰的类叫抽象类，用 abstract 修饰的方法叫抽象方法。

* 抽象类不能被实例化。

* 抽象方法只需声明，而不需实现。

* 含有抽象方法的类必须被声明为抽象类，抽象类必须被继承（说的是，若你定义了一个抽象类，该类不被其它类继承的话就没有意义，因为抽象类不能实例化，所以你无法使用该抽象类中的静态及动态属性），继承抽象类的子类必须重写该抽象父类中所有的抽象方法

* 补充说明：abstract class 中可以有非抽象方法，而 interface 不可以。

 

 

 

final 关键字： 

* final 的变量的值不能被改变，且必须初始化。

  ** final 的成员变量

  ** final 的局部变量（形参）

* final 的方法不能被重写

* final 的类不能被继承

 

 

接口（interface）： 

* 接口是抽象方法和常量值的定义的集合。

* 从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量、方法的定义，而没有变量，没有方法的实现。

* 多个无关的类可以实现同一个接口。

* 一个类可以实现多个无关的接口。

* 与继承关系类似，接口与实现类之间存在多态性。

* 补充说明：interface 只能 extends interface ，不能 extends class 或者 extends abstract class ，interface 本身不能 implements 任何 interface

 

 

 

总结：

* 内存分析贯穿始终

* 对象和类的概念

* 类（对象）之间的关系

* 面向对象设计思想

* class

* new

  ** 引用的概念

  ** 构造方法的概念

* 方法重载（overload）

  ** 构造方法重载

* this

* static

* package & import

* private default protected public（default不是关键字）

* extends

* overwrite

* final

* Object

  ** toString

  ** equals

* upcasting downcasting

* polymophysm / ( dynamic / late ) binding

* abstract class

* interface

  ** implements