编程语言：
1）机器语言： 0 1（在硬件上直接运行）
2）汇编语言：也称为符号语言
3）高级语言：
面向过程的高级语言：程序设计的基本单位为函数，c,c++
面向对象的高级语言：程序设计的基本单位为类，java,c#
Java语言的特点：平台无关性，面向对象，多线程，自动内存管理
（自动内存管理：对临时存储的数据自动进行回收）
1.Java开发环境:
1)java编译运行过程:
1.1)编译期: .java源文件，经过编译，生成.class字节码文件
1.2)运行期:JVM加载.class并运行.class字节码文件
特点:跨平台、一次编程到处使用
2、名词解释:
2.1)JVM:java虚拟机，加载.class并运行.class
2.2)JRE:java运行环境
除了包含JVM以外还包含了运行java程序所必须的环境
JRE=JVM+java系统类库(小零件)
2.3)JDK:java开发工具包
除了包含JRE以外还包含了开发java程序所必须的命令工具
JDK=JRE+编译、运行等命令工具
注： 1）运行java程序的最小环境是JRE
2）开发java程序的最小开发工具是JDK
3、java中的注释:解释性文本
3.1)单行注释://
3.2)多行注释:/* */
3.3)文档注释:/** */
4、变量:存数的，代词，指代的是它所存的那个数
1)声明:
int a; //声明一个整型的变量，名为a
int b,c,d; //声明三个整型的变量，名为b,c,d
2)初始化:第一次赋值
2.1)声明的同时初始化: int a = 250;
2.2)先声明后初始化:
int a; a = 250;
注： 1)对变量的使用就是对它所存的那个数的使用
2)变量的使用必须与数据类型匹配
3)变量在前之前必须声明并初始化
5、变量的命名规则（JAVA标识符的命名规则）:
1)只能包含字母、数字、_和$符，并且不能以数字开头
2)严格区分大小写
3)不能使用关键字
4)可以中文命名但不建议
（建议:"英文的见名知意"、"驼峰命名法"）
6、基本数据类型:（原始数据类型）
1)int:整型，4个字节，
1.1)整数直接量默认为int类型，但不能超出范围，若超范围则编译错误
1.2)两个整数相除，结果还是整数，小数位无条件舍弃
1.3)整数运算时超出范围，则发生溢出，溢出是需在避免的
2)long:长整型，8个字节，
2.1)长整型直接量需在数字后加L或l 0L
2.2)运算时若有可能溢出，建议在第1个数字后加L
2.3)System.currentTimeMillis()用于获取自1970.1.1零时到此时此刻的毫秒数
3)double:浮点型，8个字节，
3.1)浮点型直接量默认为double型，
3.2)double和float型数据运算时，有可能会出现舍入误差，所以精确运算场合不能用
4）float:4个字节，赋值时在后面加f或者F
4)boolean:布尔型，1个字节，
只能存储true或false，默认值是false
5)char:字符型，2个字节
5.1)采用Unicode字符集编码，每个字符对应一个码
表现的形式是字符char，实质上存储的是码int
(ASCII码: 'a'--97 'A'--65 '0'--48)
5.2)字符直接量必须放在单引号中，只能有一个
5.3)特殊符号需要通过\来转义
Byte :1个字节 ，取值范围：-128~127
Short :2个字节，取值范围：-32768~32767
char:2个字节， 取值范围：0-65535
可以存储汉字的：char、short、int long float double
7.基本数据类型间的转换:
基本类型从小到大依次为:
byte,short,int,long,float,double
char,
long在内存中占用8个字节共64位，它表示的数值有2的64次方，平分正负，数值范围是负2的63次方到正2的63次方-1。
而float在内存中占4个字节，共32位，但是浮点数在内存中是：
V=(-1)^s * M * 2^E
浮点数的32位不是简单的直接表示大小，而是按照一定的标准分配的。
其中第1位，符号位，即S。
接下来的8位，指数域，即E。
剩下的23位，小数域，即M，M的取值范围为[1，2）或[0，1）。浮点数在内存中的二进制值不是直接转换为十进制数值的，而是按照上述公式计算而来，通过这个公式，虽然只用到了4个字节，但是浮点数却比长整型的最大值要大。
1)两种方式:
1.1)自动类型转换:从小类型到大类型
1.2)强制类型转换:从大类型到小类型
语法:(要转换成为的数据类型)变量
强转有可能会溢出或丢失精度
2)两点规则:
2.1)整数直接量可以直接赋值给byte,short,char，但不能超出范围
2.2)byte,short,char型数据参与运算时，先一律转换为int再运算
8、运算符:
1)算术:+,-,*,/,%,++,--
2)关系:>,<,>=,<=,==,!=
3)逻辑:&&,||,!
4)赋值:=,+=,-=,*=,/=,%=
5)字符串连接:+
6)条件/三目:boolean?数1:数2
9.分支结构:
1)if结构:1条路
{}可以省略,但是不写{}只对一行代码生效，所以不建议省略
2)if...else结构:2条路
3)if...else if结构:多条路
4)switch..case结构:多条路
优点:效率高、结构清晰
缺点:整数、相等
break:跳出switch
JDK1.6之前的版本：等价成int 基本类型的数据:byte ,short,char,int
（JDK1.7以后的版本包含JDk1.7可以是（String 、short、int、byte、char）
break与continue的区别？
break是跳出循环，continue是跳过本次循坏的剩余语句，进行下一次循环。
9.循环:
1)反复执行一段相同或相似的代码
3)循环结构:
3.1)while:先判断后执行，有可能一次都不执行
3.2)do...while:先执行后判断，至少执行一次
1.for:固定次数循环，应用率高
2. break:跳出循环
continue:跳过循环体中剩余语句而进入下一次循环
3)break只能跳出一层循环（可以跳出多层循环使用标记）
int n=3;
loop: for(int i = 0; i<n ; i++){
for(int j = 0; j<n ;j++){
for(int k = 0; k<n; k++){ System.out.println("i="+i+",j="+j+",k="+k);
break loop;
}
}
}
5.程序=算法+数据结构
1)算法:解决问题的流程/步骤(顺序、分支、循环)
2)数据结构:将数据按照某种特定的结构来保存(数怎么存)
设计合理的/良好的数据结构会导致好的算法
6.数组:
1)是一种数据类型(引用类型)
2)相同数据类型元素的集合
3)数组的定义:
int[] arr = new int[10];
int arr[] =new int[10];
4)数组的初始化:
int[] arr = new int[4]; //0,0,0,0
int[] arr = {1,4,5,7}; //1,4,5,7
int[] arr = new int[]{1,4,5,7}; //1,4,5,7
int[] arr;
arr = {1,4,5,7}; //编译错误，
arr = new int[]{1,4,5,7}; //正确
5)数组的访问:
5.1)通过(数组名.length)来获取数组的长度(元素的个数)
5.2)通过下标/索引来访问数组中的元素下标从0开始，最大到(数组的长度-1)
1.数组:
1)复制:
1.1)System.arraycopy(a,1,a1,0,4);
1.2) Arrays.copyOf(a,6);
排序：Arrays.sort(arr); //升序
2.方法:
1)封装一段特定的业务逻辑功能
2)方法尽可能独立，只干一件事
3)方法可以被反复多次的调用
4)减少代码的重复，有利于代码的维护，有利于团队的协作
3.方法的定义:
修饰词 返回值类型 方法名(参数列表){
方法体
}
4.方法的调用:
1)无返回值: 方法名(有参传参);
2)有返回值: 数据类型 变量 = 方法名(有参传参);
+
104 1)return 值; //1.1)结束方法的执行 1.2)返回结果给调用方
2)return; //2.1)结束方法的执行
1.什么是类？什么是对象？
1)类是同类型东西的概念，对现实生活中事物的描述，映射到JAVA中描述就是class定义的类。类是对象数据结构定义。
2)对象:真实存在的单个的个体
类:类型/类别，代表一类个体
3)类中可以包含:
3.1)所有对象所共有的属性/特征------成员变量(属性)
3.2)所有对象所共有的行为-------方法（函数）
3.3）构造函数
4)一个类可以创建多个对象，
同一类型的多个对象，结构相同，数据不同
5)类是对象的模板，对象是类的具体的实例
2.方法的重载(Overload):
1)发生在一个类中，方法名称相同，参数列表不同
2)编译器在编译时会根据方法的签名自动绑定调用的方法
2.构造方法:（构造函数、构造器，构建器）
1)给成员变量赋初值
2)与类同名、没有返回值类型
3)在创建(new)对象时被自动调用
4)若自己不写构造方法，则编译器默认一个无参构造方法，
若自己写了构造方法，则不再默认提供
5)构造方法可以重载
3.this:指代当前对象，哪个对象调用方法指的就是哪个对象
只能用在方法体中，方法中访问成员变量之前默认有个this.
this的用法:
1)this.成员变量名--------------访问成员变量
2)this.方法名()----------------调用方法(几乎不用)
3)this()-----------------------调用构造方法
4.super:指代当前对象的超类对象
super的用法:
super.成员变量名---------访问超类的成员变量
super.方法名()-----------调用超类的方法
super()------------------调用超类的构造方法
5.继承:
1)作用:代码复用
2)通过extends来实现继承
3)超类:所有派生类所共有的属性和行为
派生类:派生类所特有的属性和行为
4)派生类继承超类后，派生类具有:派生类的+超类的
5)一个超类可以有多个派生类
一个派生类只能有一个超类-----------单一继承
6)继承具有传递性
7)java规定:构造派生类之前必须构造超类
在派生类的构造方法中，若自己不调用超类的构造方法
--------------则默认super()调用超类的无参构造方法
在派生类的构造方法中，若自己调用了超类的构造方法
--------------则不再默认提供
super()调用超类的构造必须位于派生类构造中的第一行
6.null:空，没有指向任何对象
若引用的值为null，则该引用不能进行任何操作
若操作则发生NullPointerException空指针异常
7.向上造型:
1)超类型的引用指向派生类的对象
2)能点出来什么，看引用的类型
8.方法的重写(Override):覆盖
1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
2)重写方法被调用时，看对象的类型
3)遵循"两同两小一大"原则: 3.1)两同:
3.1.1)方法名称相同
3.1.2)参数列表相同
3.2)两小:
3.2.1)派生类方法的返回值类型小于或等于超类方法的
1)void时，必须相等
2)基本类型时，必须相等
3)引用类型时，小于或等于
3.2.2)派生类方法抛出的异常小于或等于超类方法的
3.3)一大:
3.3.1)派生类方法的访问权限大于或等于超类方法的
3.重写与重载的区别
1)重写(Override):
发生在父子类中，方法名称相同，参数列表相同，方法体不同
遵循"运行期"绑定，看对象的类型来调用方法
2)重载(Overload):
发生在一个类中，方法名称相同，参数列表不同，方法体不同
遵循"编译期"绑定，看参数/引用的类型来绑定方法
1.package:
1)作用:避免类的命名冲突
2)类的全称: 包名.类名
3)包名可以有层次结构
4)建议:包名所有字母都小写
import:
1)同包中的类可以直接访问，
不同包中的类不能直接访问，想访问有如下两种方式:
1.1)先import声明类，再直接访问类-
1.2)类的全称
2.访问控制修饰符:
1)public:公开的，任何类
2)protected:受保护的，本类、子类、同包类
3)默认的:什么也不写，本类、同包类
4)private:私有的，本类
说明:
1)类的访问修饰符只能是public或默认的
2)类中成员的访问修饰符如上4种都可以
3.final:最终的、不可改变的-------应用率低
1)修饰变量:变量不能被改变
2)修饰方法:方法不能被重写
3)修饰类:类不能被继承
4.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)属于类的，在类被加载期间自动执行的，
因类只被加载一次，所以静态块也只执行一次
3.2)何时用:初始化/加载静态资源(图片、音频、视频等)
1.static final常量: 应用率高
1)必须声明同时初始化
2)通过类名点来访问，常量不能被改变
3)建议:常量名所有字母都大写，多个单词用_分隔
4)编译器在编译时将常量自动替换为具体的值，效率高
5)何时用:数据经常使用，并且永远不变
2.抽象方法:
1)由abstract修饰
2)只有方法的定义，没有方法的具体实现(连{}都没有)
3.抽象类:
1)由abstract修饰
2)包含抽象方法的类必须是抽象类
3)不能被实例化
4)抽象类是需要被继承的（继承之后需要重写里面的抽象方法）
5)抽象类的意义:
5.1)封装派生类所共有的属性和行为--------代码复用
5.2)为所有派生类提供一种统一的类型------向上造型
5.3)可以包含抽象方法，为所有派生类提供统一的入口，
派生类的具体行为不同
.成员内部类:
类中套类，内部类对外不具备可见性，通常是在外部类中创建内部类的对象
内部类中可以直接访问外部类的成员(包括私有的)
内部类中有个隐式的引用指向了创建它的外部类对象
外部类名.this.???
2.匿名内部类:
若想创建一个类(派生类)的对象，并且对象只创建一个，
此时该类不必命名，称之为匿名内部类
1.接口:
1)是引用数据类型
2)由interface定义
3)只能包含常量和抽象方法
4)接口不能被实例化
5)接口是需要被实现/继承的，实现类/派生类:
必须重写接口中的所有抽象方法
6)一个类可以实现多个接口，用逗号分隔
若又继承又实现时，应先继承后实现
7)接口可以继承接口（接口可以多继承）
2.多态:（表现形式：重写和重载）
1)意义:
1.1)同一类型的引用在指向不同的对象时，有不同的实现
------行为的多态
1.2)同一个对象被造型为不同的类型时，有不同的功能
------对象的多态
2)向上造型:
2.1)超类型的引用指向派生类的对象
2.2)能造型成为的类型有: 超类+所实现的接口
2.3)能点出来什么，看引用的类型
3)强制类型转换，成功的条件只有如下两种:
3.1)引用所指向的对象，就是该类型
3.2)引用所指向的对象，实现了该接口/继承了该类
4)强转若不符合如上两个条件，则发生ClassCastException类型转换异常，
建议:强转之前instanceof判断引用指向的对象是否是该类型
设计规则:
1)将所有派生类所共有的属性和行为，设计在超类（父类）中
2)所有派生类行为都一样，设计为普通方法
所有派生类行为都不一样，设计为抽象方法
3)将部分派生类所共有的行为，设计在接口中
符合既是也是原则时，使用接口
接口是对继承的单根性的扩展----------实现多继承
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
