基本数据类型 ？

整数

Btye 1个字节 取之范围 -128—127 在内存中占8位

Short 2个字节 取之范围 -32768 — 32767在内存中占16位

Int 4个字节 取之范围 2147483648 — 2147483647在内存中占32位

Long 8个字节 取之范围 -9223372036854775808 — 9223372036854775807 在内存中占64位

小数

Float 4个字节 取之范围 3.4028235E38 - 1.4E-45

在内存中占32位

Double 8个字节

取值范围1.7976931348623157E308- 4.9E-324

在内存中占64位

字符

Char 2个字节 取之范围 单个字符

在内存中占16位

Boolean 1个字节 取之范围 true / false

在内存中占8位

基本小常识

表示这个数据在内存中要占多大的空间，如一个int数据在内存中占4个字节，而1024个字节=1KB，1024KB=1MB，1024MB=1GB，1024G =1BT内存其实就是这样算的，不过产家一般是以1000为单位，而这些数据类型占多少个字节其实就是说所占你内存空间的多少。如：int占4个字节,long占8个，float占8个，double占16个。

同时占多少个字节也说明这个数所能表示数据的最大范围，一个字节有8位，那么8位我们所表示的数据最大为0到255，如果是有符号的最高位表示为符号，那么就是-128到127，以int为例，它的表示范围应当是-2的31次方到2的31次方再减1这个范围，如果超过这个范围那它就容不下你必须使用容量更大的数据类型。而float和double都是带有小数的，long和int还有short代表的是整数。

这与系统硬件环境有关，如果是 32 位架构 CPU 的话那么int的字长就是 4 个字节，一个字长的处理效率是最高的。因此，JVM 厂商一般以 1 个字长作为最小处理单元。

如果是 64 位架构的 CPU 那么int 的字节就会达到 8 个字节。也就是说，如果是 64 位环境中一个 int 可能占据 8 个字节的空间，但这并不会影响到 int 值的范围。

基本运算符

数字运算

加、 减 、乘、除、取余。

三目运算符：a>b?true:false

自增：++ --

关系运算符：>= <= != ==

逻辑运算符：|| &&

位运算符 与（&）、非（~）、或（|）、异或（^）

希望大家，将不足的地方告诉我

变量

Int a =1; 此种语法就是创建一个变量

基本数据类型转换

Btye à short àInt à long

Btye à short àInt à float à double

很多书上都说大数字类型转换小数字类型，就是因为小数字类型装不下，这样说也对，但是这种说法也太笼统了

在进行大数字类型向小数字类型转换过程是这样的

比如int 向 btye 转换

首先将int 转换成32 位的二进制数字

在将转换好的32位二进制数字，转换成八位二进制数字，在转换的同时会将32位二进制数字截断成8位二进制数字，将左边的24位二进制舍弃，只保留Btye 能装的下的八位二进制数字，这才是强制类型的转换过程！

赋值： = += -= *= /= %= &= ^= |= <<= >>=

Int final b =2； 此种语法是创建一个不可改变的变量，称之为常量，虽说不可改变，反之通过某种手段，可以将final 变量改造成魔数字，代码如下

创建一个类

次类中拥有一个 Random r =newRadmon 对象和 一个int final i变量， 需要导入，java.util.Radmon;包

为int final 变量赋值 其语法 i=r.nextInt(100);

创建一个test 类 实验

此种语法已出现，还是final 吗？

当然还是final 了， 只是在为final 变量赋值的同时调用了java.util包中Radmon.nextInt()方法，为final 变量生成随机数

如果再次改变，编辑器将报错！在此证明final变量仅仅只是在值确定的时候不能改变，反之如果final 变量的值尚未确定，是能改变的，并不是有了final 修饰符就不能改变。

基本控制流

分支语句

If else,细节说明，将 if else 语句联合使用，else 必须执行

Switch ,先判断在执行

循环语句

while ,先判断在执行

dowhile ,先执行在判断

for ,先判断在执行

Foreach,先判断在执行

控制循环结构语句

break ,当前循环结束

continue,跳过本次循环,继续执行下次循环

return ,返回方法调用出

继承

继承的特点 减少重复代码，但是继承需要按照is –a 的规范来继承，extends其实翻译出来并不是继承，而是英国的扩展，关键字如果有一个Person 类和一个plant 类，如果你用Plant 类继承 Person类，这明显说不过去，植物类怎么可以继承人类呢！

在实现继承体系之后，子类必须实现父类中的方法，在子类中不可以访问在父类中用private 修饰的方法或属性，

子类构造函数实力化过程

当为子类构造赋值的时候，必须是父类属性先赋值，如果父类，没有赋值，那么就永远不会轮到子类，在子类覆写方法的时候往往都会加上super(); 此语法是调用父类构造函数

在子类中使用父类中的方法或者属性的时候，没有this，当然是用this来调用也是没有错的，但是java 会先在子类中找对应的方法，和属性，如果没有还会到父类中去寻找，如果父类中也没有，那编辑器将会做出错误提示，如果在父类中存在一个 str 的属性。子类中也存在一个str 的属性，那么使用this.str 必然就是子类中的str 就不是父类中的str 了，所以在使用的使用要注意一下

判断某一个子类能不能像向上类型转换，或者某一个父类是否可以向下类型转换，可以实用 Instanceof关键字来判断

多态

多态是在继承的体系上扩展出来的，有了继承自然就有了多态，但是多态也有调用原则如果是用子类调用自己的方法和属性，则叫多态，多态就是通过父类对象来调用子类的方法，在父调用父类中方式的时候，父类会调用被被子类覆写的方法

抽象类

抽象类是一种模板的形式，在abstract 类中可以定义 abstract 方法，可以定义非abstract 方法，但是仅仅只是抽象类才能行，抽象类不可以有实例化对象，只能通过子类来实力化对象，出此之外没有和普通类没有什么区别，但是有一点注意，如果在抽象类中定义一个熟悉并且为它赋上初始值，基本上是没有人这样做的，因为当子类覆写的时候可以为属性赋值，这样父类中的初始值就没有了，在继承的时候也是这样的，这样简直是浪费内存

接口

接口是继承的扩展，比如我现在有一个类专门提供，共享资源，任何人都可以使用，在定义一个Students 类，来获取资源，大家都知道java.lang.Thread 是一个多线程类，如果Students继承Thread，必须实现run 方法，但是这样还符合is-a 继承的规范吗？当然如果写出这样的代码完全是没有任何问题的。如果继承了Thread类有两点不是很好，第一步不符合is-a 的规范，第二Students 类一旦继承了Thread类将无法在继承其他类了，这样的程扩展性超级差，当然，我们都能想到，开发java 的人能想不到吗？在Thread 中有一个Runnable 接口，此接口和Thread类功能一样，但是这样有一个好处，只要实现此接口，就能创建多线程，没有继承当然就没有is-a 的规范了、接口和抽象类基本基本上一样，但是就如上面所说的，如果继承了Thread 类，Students 类就无法得到扩展，接口代码规范和功能，你说说在person中有一个线程专门来获取资源功能，是不是合情合理。

封装

首先说说封装的基本概念，封装就是，将隐藏所有如何实现的细节，和对象的属性，只是对外提供一个及其简单的方法，让别人访问的时候仅仅只是知道这样方法的功能是什么，而不知道内部是如何实现的，这样就做到数据的安全性。尽可能的把一切都影藏起来！

内部类

内部类的基本概念

在一个类的内部，就叫内部类（一般内部类的定义都是希望别人不可以随便访问的，仅仅只提供一个方法在访问，内部类可以使用private 来修饰，当一个类想要直接访问某一个类的成员时，就使用内部类）

内部类访问语法

Outer.Inner in =new Outer().new Inner();

内部类的好处就是能直接访问外部类的所有成员，包括private属性，和方法。如果单独创建，前面说过对象方法的访问形式只有两种，要么创建对象来访问，要么直接类点方法名称，和类点属性名称，但是如果在一个类中创建一个内部类，并且类使用private 修饰，放心你永远访问不到，这样就体现出了内部类的好处了，如果内部类没有使用private修饰，就可以使用上面的语句，来访问内部类的方法，如果不想让别人通过new 来访问内部类，就将内部类设置为private 在外部类中创建一个对象，并且在外部类提供一个方法内部类的方法即可

Static 内部类

如果内部类是用Static 修饰

可以使用Outer.Inner out =new uOuter.Inner();

Out.print();方法即可，就不用在创建外部类的对象了

当内部类中存在static 属性，或者static方法，该内部类必须是static修饰 ，因为Static 属性或方法是随着类的加载而加载，可以想想如果内部类没有用Static 修饰就证明次类中一定没有Static 属性或方法，这时候当在用Static 修饰的时候系程序将出现错误，反之，当外部部类访问，内部类中的Static 方法时，内部类中的方法也必须是Static 修饰

当在方法中定义内部类的时候，内部类是不可以定义成Static 的，方法也是一样

在方法中定义内部类的时候想要访问内部类的方法或者属性的时候需要在外部类的方法最后一行创建一个内部类的对象，并且来调用内部类的方法，当要使用内部类的方法的时候，仅仅只需创建外部类的对象，调用次方法，即可。

当内部类定义在方法中的使用，内部类中得方法如果想要访问它所在的局部变量，前提是局部变量必须以final 修饰

内部类中可以实现继承，和实现接口，代码如下：

Public class Outer{

Calss temp extends Thread{

public void run(){

}

}

}

在方法中实现内部类并且调用方法，称之匿名内部类

public void temp(){

new Thread(){

public void run(){

System.out.println();

}

}.start();

}