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:字符串是常量：字符串对象一旦创建 字符序列不能更改
