java基础知识点总结 1

>标示符： 全部的名字 和同类区分 方便调用
       命名规则：由数字字母_$组成 不能以数字开头 区分大小写 不能是java关键字
命名规范：尽可能增长可读性
类名：全部单词首字母大写
变量名/方法名:除了第一个单词 其余单词首字母大写
final常量： 全部字母大写
>关键字：java中被赋予特殊含义的单词或者字符
static void
byte short int long float double boolean char
protected private public
static final abstract synchronized
class interface
instanceof
try catch throws throw finally
if else for while do break continue return
switch case default
{} () <> [] ; : ? ,
**** >数据类型：
先数据性质分类 再按空间大小分类
整数类型：没有小数点的数字
---byte 字节型 [-128,127] 是java描述数据的最小单位
---short 短整型 占2个字节
---int 整型 占4个字节 一个整数常量默认是int类型
---long 长整型 占8个字节 一个整数常量后面有l/L 是long类型
浮点类型：有小数点的数字
---float 单精度 占4个字节 浮点常量后面加f/F 是float类型
---double 双精度 占8个字节 浮点类型常量默认是double
字符类型：全部的符号
---char 字符型 占2个字节 char类型的常量必须有'' 单引号中有且只有一个字符
布尔类型：只有两种选择 而且是相反的
---boolean 布尔型 占1个字节 true、false
*****>数类型转换
自动类型转换状况一： 高精度变量=低精度数据;
float f1=12;
自动把int类型4个字节的12 转换为float类型4个字节的12.0f
自动类型转换状况二： byte、short,char类型的变量=int常量值;
byte b1=13;
先检测b1是否能装下13 会把4个字节int类型的13 自动转换为1个字节byte类型的13
short s1=999999;
检测s1不能装下999999 再也不转换 直接报错
强制类型转换： 低精度变量=(低精度变量类型)高精度数据;
int i1=(int)12.3;
>运算后结果的数据类型
1 byte short char 不能直接参加运算 必须转换为int参加运算
2 运算后结果的数据类型取决于精度最高的数据 '1'+(byte)12+12+12.5
>运算符
1 算术运算符：+ - *／
　　　　　　　　％　求余　取模　　　n%m=n除以m获得一个整数 除不尽的那部分
4.5%1.1=0.1
++ --自增自减
a++;++a;彻底等价于 a=(a的类型)(a+1);
b=a++;彻底等价于 b=a;a++
b=++a;彻底等价于a++;b=a;
int i=2;//3
int j=(i++)+(i/++i)+(--i)+(i--)+(++i*2)+i/3;
// 2 + 3/4 + 3+ 3 + 3*2+3/3
//++在前 就先自增 后参加本次运算
//++在后 先参加本次运算 后自增
+ 字符串链接符
而后数据与字符串链接 都造成一个新的字符串
2 比较运算符： > >= < <=
!= 不等号 判断两边的数据是否是不相等
== 恒等号 判断两边的数据是否是相等
3 赋值运算符：= 把等号右边的值赋值给左边的变量
a+=b;彻底等价于 a=(a的类型)(a+b);
a-=b;彻底等价于 a=(a的类型)(a-b);
a*=b;彻底等价于 a=(a的类型)(a*b);
a/=b;彻底等价于 a=(a的类型)(a/b);
a%=b;彻底等价于 a=(a的类型)(a%b);

short s=12; s=s+1;
short s=12; s+=1;
4 逻辑运算符:
& && and 两个只要有一个false 结果就是false
| || or 两个只要有一个true 结果就是true
^ 异或 两边相同则为false 两边不一样才为true
!
单与双的区别：
相同之处： 做为逻辑运算符时 &和&& |和||结果都是同样
不一样之处：(1)双的时候 有逻辑短路 当第一个表达式就知道结果时 第二个表达式就再也不执行 直接给出结果
(2)单还能够做为位运算符 操做的数字的二进制
5 位运算符：（ 操做的数字的二进制）
>>
<<
&
|
^
6 三元运算符：boolean类型的数据?值1:值2

>流程控制：
顺序结构：从左到右 从上到下
选择结构：代码书写规范 对齐缩进
if(){}
if(){}else{}
if(){}else if(){}else{}
swicth(表达式){
case 值1:
语句块1;
break;
case 值2:
语句块2;
break;
case 值3:
语句块3;
break;
case 值4:
语句块4;
//break;
default:
语句块n;
break;
}
注意：(1) case后面的值不能重复
(2)switch后面表达式值的数据类型 仅限于 byte short char int
(3)只有当全部的case的值都不予switch表达式的值相等时 才运行default
与其位置无关
(4) break做用是结束整个switch结构

循环结构:
while(){}
do{}while();
for(;;){}

for(int a=1;a<=10;a++){
for(int b=1;b<=10;b++){

}
}
跳转:
continue:结束本次循环 继续i++进行下次循环
break: 结束整个循环
数组：装相同类型 指定个数个数据的容器
建立时必须明确：装什么(元素类型) 装多少 (元素个数)
关键字:[]
建立数组格式： (1) 元素类型[] 数组名=new 元素类型[元素个数];
(2) 元素类型[] 数组名=new 元素类型[]{值1,值2,值3....};
(3) 元素类型[] 数组名={值1,值2,值3....};
求最大值：
//定义变量记录最大值 赋初始值为第一个元素的值
int max=arr[0];
//拿max与数组的其余元素作比较
for(int i=1;i<arr.length;i++){
max=arr[i]>max?arr[i]:max;
}
数组排序：
顺序排序：依次拿当前元素和其后面的全部元素做比较
for(int i=0;i<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]<arr[j]){
int k=arr[i];
arr[i]=arr[j];
arr[j]=k;
}
}
}
冒泡排序：依次拿相邻的元素做比较
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-1-i;j++){
if(arr[j+1]<arr[j]){
int k=arr[i];
arr[i]=arr[j+1];
arr[j+1]=k;
}
}
}
插入排序： 假设前面的元素时有序的 依次拿当前元素倒着和其前面的元素作比较
for(int i=1;i<arr.length;i++){
//定义变量记录当前元素
int k=arr[i];
//定义变量记录前面的元素的下标
int j;
for(j=i-1;j>=0;j--){
if(k>arr[j]){
arr[j+1]=arr[j];
}else{
break;
}
}
//把k放在j+1位置处
arr[j+1]=k;
}

面向对象 567
面向对象：找具备帮助我解决问题功能的对象 指挥对象解决问题
eg:找饭店吃饭
面向过程：把解决问题的过程按动做分红多个步骤 逐个步骤去完成
eg:本身作饭吃
优势： >把复杂问题简单化
>程序员的角色由执行者转换为指挥者
>更符合如今人的思惟方式
使用面向对象写程序步骤：
(1)建立类描述一类事物
提取表面的数据作成员变量
提取动态的功能作成员方法
(2)根据类建立对象：类名 对象名=new 构造方法;
类中定义了那些成员变量 直接决定了对象拥有那些属性
类中定义了那些成员方法 直接决定了对象拥有那些功能
(3) 给对象的属性赋值
(4) 调用对象的方法 解决问题

类：对一类事物的描述 是建立对象的设计图纸 模板
对象：现实事物在电脑中的模型 类的实例

成员：成员变量 成员方法(构造方法 普通方法) 内部类 静态代码块 构造代码块

成员变量和局部变量：
(1)定义的位置不一样
(2)做用域不一样
(3)是否有默认初始值
(4)修饰符不一样

重载：一个类中几个方法 方法名相同 参数列表不一样的现象
要求：同一个类 方法名相同 参数列表必须不一样(参数个数不一样 参数类型不一样 参数顺序不一样)
重写：父类的方法没法知足子类的需求 子类根据本身的需求从新定义父类的已有的方法
要求：除了范围修饰符能够扩大 抛出少的小的异常 其余方法声明必须和父类彻底同样
区别：>位置不一样：重载是在一个类中 重写发生在子类中
>要求不一样： 重载要求：同一个类 方法名相同 参数列表必须不一样
重写要求： 除了范围修饰符能够扩大 抛出少的小的异常 其余方法声明必须和父类彻底同样
>影响不一样：
重载的方法之间相互无响应 ：只是经过方法参数列表来区分
子类重写父类的方法 父类的方法会被隐藏

构造方法：建立对象时调用的方法
构造方法和普通方法的区别：
>格式不一样：构造方法没有返回值 不用void标示
>做用不一样：构造方法做用是建立对象
普通方法 表明此类的对象具备的某一指定功能
>调用不一样：构造被关键字new调用 调用一次建立一个新的对象
普通方法被对象调用 一个对象能够调用屡次普通方法
>命名不一样：构造方法名字必须和类名相同
普通方法名字能够是类名(按规范不能是类名)
>是否有默认： 一个类没有构造方法 默认添加一个无参数的构造方法

建立对象内存图：
>类加载 若是类有静态成员 还要建立静态区域
>建立引用
>建立对象：
>>经过super(12,11)把父类中定义的成员加载进子类对象内存中
并给属性赋默认初始值
>>经过super(12,11) 运行父类构造方法中的其余语句
>>经过子类构造方法 把子类中定义的成员加载进子类对象内存中
并给属性赋默认初始值
>>隐藏父类被从新定义的成员
>>运行子类构造方法中的其余语句
>然引用指向建立的对象

static:静态 修饰符
static修饰的成员：静态成员 类成员
无static修饰的成员：实例成员
static修饰变量：类变量 共享数据
> static修饰变量不但能够被对象调用 还能够被类直接调用
> static修饰变量 一个对象更改此属性的值 其余对象的此属性值都被更改
static修饰方法
> static修饰方法不但能够被对象调用 还能够被类直接调用
> static修饰方法只能调用静态成员

this:
使用场景一：当成员变量和局部变量重名时 变量名默认指向局部变量
经过this.变量名来指向成员变量
注意:全部成员前面默认有this. （当前对象）
使用场景二：一个构造方法调用另一个构造方法(复用其方法体)
经过this(参数列表)调用指定的构造方法
注意：this(参数列表)必须是第一个语句

继承：extends
当一个新类拥有一个现有的类的全部成员时 可让此新类从现有的类派生 衍生
格式：class Zi extends Fu{}
特色：
>子类能够继承父类全部的成员
>子类能够继承父类的私有成员 但不能直接使用 只能经过父类的其余方法间接使用
>子类不能继承父类的构造方法
>子类能够拥有子类特有的成员
>子类能够从新定义父类的成员
从新定义父类的成员变量：要求变量名相同便可
从新定义父类的成员方法：重写 除了范围修饰符能够扩大 抛出少的小的异常 其余方法声明必须和父类彻底同样
>全部子类构造方法的第一个语句 默认调用父类无参数的构造方法
经过super(参数列表)来调用父类有参数的构造方法
>java只支持类的单继承

多态：
什么是多态：给一个子类对象起个父类名字
多态的对象有什么特色：除了重写的方法其余和父类对象彻底同样
怎么使用多态：
定义方法参数列表时 定义方法返回值类型时 定义类的成员变量时 定义数组时 都定义为父类类型
这样就能够 传递 返回 赋值 装任意子类类型的对象

1 提升代码复用性
2 提升程序的扩展性

抽象：abstract 模糊 不具体 信息不完整
特色：
>抽象方法 不能写方法体
>有抽象方法的类必须是抽象类
>抽象类不能建立对象 只能定义引用(指向子类对象)
>子类继承抽象类 除非重写全部的重写方法 不然仍然是抽象类
>抽象类有构造方法 经过构造方法把非抽象方法和成员变量加载进子类对象内存中

接口：interface 全部的方法都是抽象方法时 能够把此抽象类定义为接口
特色： > 接口中的变量 默认修饰符 public static final
> 接口中的方法 默认修饰符 public abstract
> 接口不能建立对象 只能定义引用 (指向的是实现类对象)
> 类经过关键字implements实现接口 一个类能够实现多个接口
> java支持接口之间的多继承

接口使用 当成抽象类使用便可
接口是规范 双方达成的协议
1 提升代码复用性
2 提升程序的扩展性
3 下降模块之间的耦合度

向上转向
向下转型
instanceof 对象 instanceof 类名
import
package



基础类库：经常使用类库 异常 集合 线程 io流 socket xml
经常使用类库：
Object: String toString() 获取当前对象的字符串表示形式
boolean equals(Object obj) 判断当前引用和参数引用是否是指向同一个对象
*重写equals方法
>方法声明不能更改
>经过instanceof判断参数对象是否是当前类的类型
>向下转型
>根据要求返回
String:字符串是常量：字符串对象一旦建立 字符序列不能更改