黑马程序员技术交流社区

标题: 技术贴 [打印本页]

作者: xinqiang 时间: 2018-7-19 00:16
标题: 技术贴
Java概念总结
环境变量的配置
JAVA_HOME---->jdk的路径
CLASS_PATH--->一个点(.)
path--------->已存在的内容不变,添加jdk下bin目录的路径
标识符
什么是标示符
Java中的：类名,变量名,方法名都是标识符,都需要遵守命名规则。
命名规则
只能由英文,_,$和数字组成且数字不能开头.
命名不能跟关键字重复(如图)
严格区分大小写
命名规范
主要是以驼峰命名法
理论上命名是没有长度限制的
命名时需要做到:见名知意,望文生义
类名:首字母大写,后续单词首字母大写
包名:全小写
方法名(函数名)/变量名:首字母小写,后续单词首字母大写
常量:字母全部大写,且单词之间用"_"分隔
基本数据类型
整型变量---用来存整数
字节型byte 1字节-128到127 默认值0
短整型short 2字节-32768到32767 默认值0
整型 int 4字节-2147483648到2147483647 默认值0
长整型long 8字节-2的63次方到2的63次方-1 L 默认值0
浮点型变量---用来存小数
单精度float 4字节F默认值0.0F
双精度double 8字节D 默认值0.0
字符变量---用来存单个字符
字符型char 2字节Unicode编码默认值'\u0000'
布尔值变量
布尔型boolean true,false 默认值false
引用数据类型
数组 array
类 class
接口 interface
基本数据类型的转换
默认转换,发生在数据类型较小的变量转换成数据类型较大的变量时
强制转换,当较大的类型转换成较小的类型时,可能会出现损失精度
注意:boolean类型不能和任何类型发生转换
数学运算符 %(取模)、 ++、 --
%代表取余数,即除不尽的数
++表示递增-- 表示递减
++变量与变量++区别
++在前面:先进行自增+1,然后有赋值再进行赋值
++在后面:有赋值先赋值,然后再进行自增+1
关系运算符 >、<、 >=、 <=、 ==、 !=
<、>、<=、>=与之前我们在数学领域使用的相同
所有的关系运算符号参加的表达式运算,都返回boolean类型
==表示比较两边的值是否相等,相等返回true,不相等返回false
!=表示比较两边的值是否不相等,相等返回false,不相等返回true,与==的取值相反
布尔运算符 &&、|| 、！
与号&&和&的运算规则
一边为假就是假两边都真才是真
或号|| 和| 的运算规则
一边为真就是真两边都假才是假
！非的运算规则
非真即为假非假即为真
短路:当表达式的第一个值决定了整个表达式真假时会短路,不再计算表达式的第二个值
条件运算符(三元运算符/三目运算符)
(表达式)?(表达式成立时执行的内容):(表达式不成立时返回的内容)
表达式中的自动类型提升
表达式求值时，Java自动的隐含的将每个byte、short或char操作数提升为int类型
判断分支
1)if(条件){
条件成立后执行的内容
}
2)if(条件){
条件成立后执行的内容
}else{
否则将会执行的内容
}
3)if(条件){
条件成立后执行的内容
}else if(条件){
条件成立后执行的内容
}else{
否则将会执行的内容
}
选择分支
switch(变量){
case 常量1:要执行的代码;break;
case 常量2:要执行的代码;break;
....
default:要执行的代码;break;
}
当遇到break时才会跳出,否则将继续执行下面的代码,直到遇到break时跳出
循环
什么时候要用循环
当我们要做重复的事情时,并且有一定规则,这个时候,我们就要用到循环
1)while循环
当条件成立后才执行大括号中的内容
格式:
设定一个初始值
while(条件/表达式){
循环执行的内容
步长
}
2)do while循环
不管条件是否为真,大括号中的内容至少会执行一次
格式:
设定一个初始值
do{
循环执行的内容
步长
}while(条件/表达式);
3)for循环
格式:
for(设定初始值;条件/表达式;步长){
循环执行的内容
}
for循环设定的初始值只可以在for循环后的大括号中使用
数组
什么是数组
同一种数据类型变量的集合
开辟了一片连续的内存空间,用来存储多个数据
数组的下标是从0开始的
一维数组
定义:
1)数据类型[] 变量名= new 数据类型[数组长度];
2)数据类型[] 变量名= {值,值,值...};//多个值之间用逗号分隔.数组的长度是值得数量
下标的取值范围:
0到数组的长度-1
超出长度后将会报下标越界异常:java.lang.ArrayIndexOutOfBoundsException
赋值:
变量名[下标] =值;
获取数组中元素的值:
变量名[下标];
遍历(对每一个元素进行一次访问):
int[] arr = {1,2,3};//定义一个一位数组
//定义循环的初始值为0(因为数组下标是从0开始的)
//循环的条件是初始值小于数组的长度,数组的长度通过:变量名.length属性获取
//步长,让它每次加一
for(int i=0;i<arr.length;i++){
arr[i];//通过下标获取数组中的元素,也就是值
}
二维数组
二维数组可以想象成为一个表格,表格里有行跟列
定义:
1)数据类型[][] 变量名= new 数据类型[行的数量][列的数量];
2)数据类型[][] 变量名= new 数据类型[行的数量][];//列的数量先不定义
变量名[哪一行] = new 数据类型[列的长度];//然后通过每一行的下标分别定义每
一行有多少列,列数可以不同
3)数据类型[][] 变量名= {{1,2,3},{2,3,4}};//直接赋值,第一个大括号中的大括号的数量是
二维数组的行数
遍历:
int[][] arr = new int[3][4];//定义一个三行四列的二维数组
//先遍历每一行,通过arr.length获取到有多少行
for(int hang=0;hang<arr.length;hang++){
//再遍历每一行的每一列,通过arr[第几行].length,获得行里有多少列
for(int lie=0;lie<arr[hang].length;lie++){
arr[hang][lie];//通过行跟列就可以定位到数组中的元素,也就是值
}
}
方法定义的位置
类里面,其他方法外,方法与方法之间是并列关系,并且不分先后顺序
方法的组成
修饰符(publicstatic),返回值类型(void),方法名(main),参数列表,方法体
什么是重载
1. 在同一个类里面,方法名相同
2. 参数列表不同,包括参数个数不同,参数类型不同,类型的顺序不同
3. 与修饰符和返回值无关
面向对象的特性
封装,继承,多态
类的组成
由成员变量(属性)和成员方法组成,并且成员方法不需要static修饰
成员变量的位置
类里面,方法外面
如何创建对象/实例化对象
类名对象名= new 类名();
构造方法的组成
修饰符,类名,参数列表,方法体
构造方法与成员方法的区别
构造函数没有返回值类型,并且构造函数的方法名必须与类名相同
构造方法的特性
构造方法是在对象实例化(new)的时候会调用
构造方法没有返回值类型
构造方法的方法名必须与类名相同
每个类中至少有一个构造函数,构造函数可以有多个,当我们类中没有写构造函数时,
Java会默认给我们提供一个无参的构造函数
封装的步骤
1. 将成员变量(属性)通过private修饰符私有化
2. 提供所有私有化属性的get/set方法
3. 提供有参或无参构造函数
this关键字
用来指代当前对象,一般用来区分成员变量和局部变量
继承的用法
1. 写在子类里面
2. publicclass 子类名extends 父类名{},extends 前的是子类,后面的是父类
3. 类只能单继承,一个类只有一个父类,但是一个父类可以有多个子类
4. 继承之后,子类可以使用父类的属性和方法,也就是拥有父类的特性
5. 子类不会继承父类的私有private特性和构造方法
6. 实例化子类时,默认先调用父类的构造方法
super的用法
用在子类里,指代的父类对象
super();//调用的是父类无参构造函数
如果要调用父类的构造函数只能放在方法的第一行
还可以用super.方法名调用父类的方法
构造方法中都会默认带着一行super();
什么是重写
1. 重写发生在继承关系中
2. 在子类中重写父类的方法
3. 要求子类中的方法的名和参数列表和返回值类型必须与父类中的完全一致
4. 子类不能重写父类的私有方法(private)和静态方法(static)
5. 子类重写父类的方法时,不能抛出比父类更大的异常
6. 子类重写父类的方法时,访问权限不能小于父类
7. 当父类的方法无法满足子类的需求时,我们通常在子类中重写父类的方法
重载和重写的区别(就是把重载和重写都写上)
重载
1. 在同一个类里面,方法名相同
2. 参数列表不同,包括参数个数不同,参数类型不同,类型的顺序不同
3. 与修饰符和返回值无关
重写
1. 重写发生在继承关系中
2. 在子类中重写父类的方法
3. 要求子类中的方法的名和参数列表和返回值类型必须与父类中的完全一致
4. 子类不能重写父类的私有方法(private)和静态方法(static)
5. 子类重写父类的方法时,不能抛出比父类更大的异常
6. 子类重写父类的方法时,访问权限不能小于父类
7. 当父类的方法无法满足子类的需求时,我们通常在子类中重写父类的方法
Object是什么
是超级类,所有的类都直接或间接的继承Object类,一个类不继承其他类,将默认继承Object类
Object的toString方法
我们通常重写这个方法,来实现返回对象的所有属性的具体信息
Object的equals方法
对象用==比较的是内存地址,如果要比较对象中所有属性是否相等,需要重写此方法
一般在重写equals方法时会同时重写hashCode方法
访问权限修饰符
关键字意思可以访问的范围
pulbic 公共的整个项目
protected 受保护的能在同一个包中使用,能在不同包的子类中使用
default 默认的只能在同一个包中使用
private 私有的只能在当前类的内部使用
访问范围从大到小:pulbic>protected>default>private
static可以修饰些什么
修饰属性:静态属性
这个类的对象所公用的
修饰方法:静态方法
static修饰的属性和方法怎么调用
可以通过:类名.属性/方法名直接调用,不用实例化对象
static修饰的属性有什么特别的
static修饰的属性可以看作是属于这个类的,所以共用这一个属性
final可以修饰些什么
修饰变量:是常量,必须设置初始值,或者在构造函数中赋值,记得常量的命名规则
修饰方法:是最终方法,不能被重写,但是能被重载
修饰类:是最终类,不能被继承
抽象(abstract)能修饰些什么
修饰类:抽象类
1. 抽象类不能被实例化,不能new对象
2. 抽象类中能通过被继承的方式使用
修饰方法:抽象方法
1. 抽象方法没有方法体,也就是没有{}
2. 抽象方法必须出现在抽象类中,抽象类中可以有普通方法
3. 如果一个类继承了抽象类,必须重写抽象类中的抽象方法,除非子类也是抽象类
abstract 不能与final同时使用
接口(interface)的特点是什么
1. 接口是一个特殊的抽象类
2. 接口里所有的方法都是抽象方法
3. 接口里所有的成员变量都是常量
4. 接口不能实例化
5. 接口可以通过类去实现(implements)接口,实现接口的类必须重写接口中的方法,除非它是抽象类
6. 接口只能被接口继承
7. 一个类可以实现多个接口
8. 不能有构造方法
9. 接口之间可以多继承
什么是多态
1. 用子类给父类赋值,父类指向子类对象
2. 用实现类给接口赋值,用接口的对象指向实现类的对象
3. 重写和重载也是多态的表现
异常的结构
Throwable
Error 错误,无法恢复的
Exception 异常,可以通过trycatch进行捕获
一般性异常需要通过trycatch进行捕获处理,或用throws将异常抛出
RuntimeException 运行时异常,可以选择捕获
捕获异常的结构
try{
可能出现异常的代码
}catch(Exception e){
出现异常时需要执行的代码
}finally{
不管是否出现异常,一定会执行的代码
这里一般用来释放资源
}
throw 和 throws
throw 生成一个异常,需要对这个异常进行处理
throws 抛出一个异常,将异常交给调用的地方处理
final finally finalize() 的区别
final:
修饰变量:是常量,必须设置初始值,或者在构造函数中赋值,记得常量的命名规则
修饰方法:是最终方法,不能被重写,但是能被重载
修饰类:是最终类,不能被继承
finally:
是与trycatch连用的语句,finally中的代码一定会被执行
finalize():
是来自Object类的一个方法,当对象要被GC回收的时候,会调用该对象的此方法
日期对象 java.util.Date;
Date date = new Date();//调用无参构造创建对象
//常用方法
date.getYear();//获得年,返回的是当前年数-1900的数值,如:今年是2016年,
则返回的是2016-1900,也就是116
date.getMonth();//获得月,返回的是0-11,0代表1月,11代表12月
date.getDate();//获得日
date.getDay();//获得市星期几,0-6,0表示星期天,1-6表示星期一到星期六
date.getTime();//返回自1970年1月1日后的毫秒数
日期格式化 java.text.SimpleDateFormat;
//调用有参构造,传递的是要展示的日期的格式
SimpleDateFormatsdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
//常用方法
sdf.format(date);//返回一个构造函数中指定了格式的字符串
//根据构造函数中规定的格式传递一个字符串,返回一个Date对象
sdf.parse("2017/08/08 23:59:59");
伪随机数 java.util.Random;
Random r = new Random();//调用无参构造函数创建对象
//常用方法
r.nextInt();//获得一个int取值范围内的随机数
r.nextInt(10);//获得一个0-9的随机数,不包括10
r.nextInt(6)+5;//获得一个5-10的随机数
String
是不可变的;最终类;无法被继承;底层实现是char数组;知道有串池的存在
尽量不要使用String进行字符串拼接的操作,也就是用+号拼接
//赋值的两种形式
String str1 = new String("金科教育");
String str2 = "万薪就业";
//常用方法
str1.indexOf("金");//返回指定字符串在str1对象中第一次出现的位置,如果不存在则返回-1
str1.length();//获得字符串的长度
str1.replace("a","b");str1.replaceAll("a","b");//将str1对象中出现的'a'全部替换成'b'并返回
str1.split(",");//将str1中的字符串用','分隔为一个String数组返回
str1.substring(5,10);//返回下标5到10之间的字符串(不包括10)
str1.toCharArray();//将字符串转换成char数组返回
str1.trim();//将字符串两端的空格去掉后返回
str1.toUpperCase();//将字符串中的英文全部转换成大写字母返回
str1.toLowerCase();//将字符串中的英文全部转换成小写字母返回
注意:replace,replaceAll,substring,trim,toUpperCase,toLowerCase方法都是返回新的字符串,
并不是修改了当前字符串
StringBuilder和StringBuffer
都是可变字符串类型,拼接效率远高于String的拼接
StringBuilder 线程不安全
StringBuffer 线程安全
//常用方法
sb.append("");//拼接字符串方法
sb.toString();//返回拼接好的字符串
String、StringBuffer、StringBuilder的区别
String 不可变字符串,拼接效率低
StringBuffer 可变类型字符串,拼接效率远高于String,线程安全
StringBuilder 可变类型字符串,拼接效率远高于String,略高于StringBuffer,线程不安全
包装类/封装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
//常用方法
对象名.xxxValue();//xxx为具体数据类型,如:对象.intValue();转换成相应语句类型的数据
//Xxx为具体数据类型,此方法为静态方法,将字符串类型的数字,转变成数值型的数字
包装类名.parseXxx();
数学类 java.lang.Math;
用来进行一些数学中的操作
该类为工具类,不需要创建对象,直接通过类名.方法名调用
//常用方法
Math.abs(值);//求值得绝对值
Math.max(值1,值2);//比较两个值中较大的并返回
Math.min(值1,值2)//比较两个值中较小的并返回
Math.random();//返回一个0.0-1.0之间的随机数(不包括1.0),类型是double类型的
集合的结构
Collection 集合父接口
List 有序集合接口,可以重复
ArrayList 线程不安全,底层由数组实现,查询快,增删慢
LinkedList 线程不安全,底层由链表实现,查询慢,增删快
Vector 线程安全
Set 无序集合接口,不可以重复
HashSet 底层由Hash码实现
TreeSet 底层由二叉树实现,可以自动排序
List和Set的区别
List:有序,有下标,List中元素可以重复
Set:无序,无下标,Set中元素不可以重复
List java.util.List;
List list = new ArrayList();//java.util.ArrayList;
//泛型的用法List<数据类型> list = new ArrayList<数据类型>();
List list = new LinkedList();//java.util.LinkedList;
//泛型的用法List<数据类型> list = new LinkedList<数据类型>();
//常用方法
list.add("万薪就业");//往集合中添加数据
list.add(0,"金科教育");//往下标0的位置插入数据
list.remove(0);//删除下标为0的元素
list.remove("金科教育");//删除元素为'金科教育'的元素
list.clear();//清空集合中的数据
list.size();//获取集合中元素的长度
list.get(0);//获取下标为0的元素
list.iterator();//获得迭代器,可以通过迭代器遍历集合中的元素
//List集合的两种遍历方法
//迭代器遍历
Iterator iterator = list.iterator();//拿到迭代器
while(iterator.hasNext()){//判断是否存在下一个元素
//如果有下一个元素,通过next()方法拿到这个元素
Object object = iterator.next();
System.out.println(object);
}
//通过下标循环遍历
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
Set java.util.Set;
Setset = new HashSet();//java.util.HashSet;
//常用方法
set.add("金科教育");//往集合中添加数据,如果有重复的将添加不进去,对象类型的参数,记得要重写equals方法才行
set.remove("金科教育");//删除元素为'金科教育'的元素
set.clear();//清空集合中的元素
set.size();//获得集合中元素的长度
set.iterator();//获得迭代器,Set集合只能通过迭代器遍历集合中的元素
//迭代遍历
Iterator iterator = set.iterator();//拿到迭代器
while(iterator.hasNext()){//判断是否存在下一个元素
//如果有下一个元素,通过next()方法拿到这个元素
Object object = iterator.next();
System.out.println(object);
}

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2