回顾java知识做了以下总结，如果有什么问题，希望能指出来一起学习（未更新完，后期补）
一、Java的简单介绍
Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。
Java分为三个体系：
- JavaSE（J2SE）（Java2 Platform Standard Edition，java平台标准版）
- JavaEE(J2EE)(Java 2 Platform,Enterprise Edition，java平台企业版)
- JavaME(J2ME)(Java 2 Platform Micro Edition，java平台微型版)。
- 主要特征：简单易学、纯面向对象程序设计语言（提供类、接口和继承等面向对象特征）、支持Internet应用（提供了用于网络应用编程的类库）、安全防范机制（类ClassLoader）、可移植、支持多个线程的同时执行，并提供多线程之间的同步机制（关键字为synchronized）
- Java开发工具：系统（Linux 系统、Mac OS 系统、Windows 95/98/2000/XP，WIN 7/8系统）。软件（IDEA、Eclipse）
二、Java基础
- Java编程Hello World！
public class Hello { public static void main(String[] args) { System.out.println("Hello World!"); } } - Java数据类型
基本数据类型：byte、short、int、long（整数）、float、double（浮点数）、char（字符）、boolean（布尔）
引用数据类型：String、接口、数组、类
注：取值范围大的数据类型向取值范围小的转换，可能会引起数据溢出，精度丢失。public class Hello { public static void main(String[] args) { //1、类型的定义 //内置数据类型:byte、short、int、long（整数）、float、double（浮点数）、char（字符）、boolean（布尔） //数值型：整型、浮点型 //整型：byte、short、int、long // int 包装类：java.lang.Integer int i = 1; System.out.println("int 二进制位数：" + Integer.SIZE); //int 二进制位数：32 System.out.println("最小值：" + Integer.MIN_VALUE); //最小值：-2147483648 System.out.println("最大值：" + Integer.MAX_VALUE); //最大值：2147483647 // long 包装类：java.lang.Long long l = 100000L; System.out.println("long 二进制位数：" + Long.SIZE); //long 二进制位数：64 System.out.println("最小值：" + Long.MIN_VALUE); //最小值：-9223372036854775808 System.out.println("最大值：" + Long.MAX_VALUE); //最大值：9223372036854775807 // byte 包装类：java.lang.Byte byte b = 10; System.out.println("byte 二进制位数：" + Byte.SIZE); //byte 二进制位数：8 System.out.println("最小值：" + Byte.MIN_VALUE); //最小值：-128 System.out.println("最大值：" + Byte.MAX_VALUE); //最大值：127 // short 包装类：java.lang.Short short s = 1000; System.out.println("short 二进制位数：" + Short.SIZE); //short 二进制位数：16 System.out.println("最小值：" + Short.MIN_VALUE); //最小值：-32768 System.out.println("最大值：" + Short.MAX_VALUE); //最大值：32767 //数据溢出问题 int number=Integer.MAX_VALUE; long rs=number+1; System.out.println(rs);//-2147483648 /** *程序执行顺序由等号的右边到左边，如果像以上计算结果就会出现数据溢出 *解决数据溢出的方式 *1、long rs=(long)number+1; *2、long num1=number; long rs=num1+1; */ //浮点型 // float 包装类：java.lang.Float float f1 = 234.5f; System.out.println("float 二进制位数：" + Float.SIZE); //float 二进制位数：32 System.out.println("最小值：" + Float.MIN_VALUE); //最小值：1.4E-45 System.out.println("最大值：" + Float.MAX_VALUE); //最大值：3.4028235E38 // double 包装类：java.lang.Double double d1 = 123.4; System.out.println("double 二进制位数：" + Double.SIZE); //double 二进制位数：64 System.out.println("最小值：" + Double.MIN_VALUE); //最小值：4.9E-324 System.out.println("最大值：" + Double.MAX_VALUE); //最大值：1.7976931348623157E308 //字符型 // char 包装类：java.lang.Character char c = 'A'; System.out.println("char 二进制位数：" + Character.SIZE); //char 二进制位数：16 // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台 System.out.println("最小值：" + (int) Character.MIN_VALUE); //最小值：0 // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台 System.out.println("最大值：" + (int) Character.MAX_VALUE); //最大值：65535 //布尔型 // boolean true/false boolean isboolean = false; if( i < 100){ isboolean=true; } System.out.println(isboolean); //true //引用数据类型:String、对象、数组 //String的使用（https://blog.csdn.net/ScarletLina/article/details/79852101） //类型之间的转换（常见）布尔型和其它基本数据类型之间不能相互转换； //byte型可以转换为short、int、、long、float和double； //int可转换为long、float和double； int a = 1; long lc = a; System.out.println(lc); //short可转换为int、long、float和double； short s1 = 1; s1 +=1;//s1 = s1 + 1;(编译错误) System.out.println(s1); //char可与int相互转换； int aa=21517; char sa=(char)aa; System.out.println("aa:"+sa); char c1 = '名'; int num =c1; System.out.println(num); //强制转换 //long可转换为float和double； //float可转换为double； } } - 注释
//单行注释
/* */区域注释
/** **/文档注释+ - 访问修饰符：public（公共的）、protect、default（包访问权限，即在整个包内可被访问）、private（私有的）。控制符能够控制类中成员的可见性
- 流程控制语句
1）、if（判断条件）{语句1；语句2；..语句n;}
2）、if（判断条件）{代码1；}else{代码2;}
3）、if（判断条件）{if（判断条件）{代码1；}else{代码2;}}else{代码2;}
4）、switch(判断表达式){
case 选择值：语句1；
break；
...
case 选择值n：语句n；
break；
default 语句n；
}
注：判断表达式的类型只能为byte、short、char、int、enmu（JDK1.5）和String(JDK1.7)
5)、while（循环条件）{语句1；语句2；...}
6)、do{语句1；语句2；...}while（循环条件判断）
7)、for(初始化语句；循环条件；迭代语句){语句1；语句2；..语句n;}
注：break（跳出整个循环）、continue（结束本次循环，继续下一轮循环）、return（返回一个值并结束该方法） - 数组是有序数据的集合
1、声明数组 数组类型[] 数组名； 数组类型 数组名[]; //示例：声明一个int类型数组 int[] intArr; 2、数组初始化 数组名=new 数据类型[]{元素值1，元素值2，...元素值n} //示例 intArr=new int[]{99，98，55，66}; 数据类型 数组名[]={元素值1，元素值2，...元素值n} int[] intArr={99，98，55，66}; 3、一维数组 int array[] = {1, 5, 3,2,5,8, 4};//数组的定义 for(int i=0;i<array.length; i++){ System.out.println(array[i] ); } 4、二维数组 //数据类型[][] 数组名 = new 数据类型[二维数组的长度/包含的一维数组的个数][每个一维数组的长度];(静态初始化) int arr[ ][ ] = { {1,2}, {2,3}, {4,5} }; int sum=0; for(int i=0;i<arr.length;i++){ for(int j=0;j<arr[i].length;j++)//利用嵌套for循环来遍历二维数组 { sum+=arr[i][j];//每遍历出一个元素则叠加一次 System.out.println("arr[i][j]:"+arr[i][j]); System.out.println("sum:"+sum); } } System.out.println(sum); // 数据类型 数组名 [ ][ ] = new 数据类型[m][n](动态初始化) // 数据类型 [ ][ ] 数组名 = new 数据类型[m][n] // 数据类型 [ ] 数组名 [ ] = new 数据类型[m][n] // int arrindex1 [ ][ ] =new int [3][2]; // int [ ]arrindex2[ ] =new int [3][2]; int [ ][ ] arrindex=new int [3][2]; //3行2列 System.out.println("arrindex的数值："); System.out.println("arrindex.length:"+arrindex.length); for(int i=0; i < arrindex.length; ++i){ System.out.println("arrindex[i].length:"+arrindex[i].length); for(int j=0; j<arrindex[i].length; ++j){ arrindex[i][j] = i*j; System.out.println(" i:"+ i); System.out.println(" j:"+ j); System.out.println("arrindex[i][j]:"+arrindex[i][j]); } } for(int i=0; i<arrindex.length; ++i) for(int j=0; j<arrindex[i].length; ++j){ System.out.println(arrindex[i][j]); } System.out.println("arrindex的数值："); - 面向对象的特点:继承、封装、多态
1）、继承：将已存在的类作为基础，建立新的技术【】 2）、封装：一种信息隐蔽技术，属性私有化，并提供公共方法访问私有对象（类的属性私有化，给属性提供get、set方法来取值赋值）
3）、多态：重写和重载public class A{ private int age; //私有属性 //提供两个公共方法，对类的私有属性进行赋值和取值 public int getAge(){ return age; } public void setAge(int age){ this.age=age; } }
重载：同一个类中含有两个或两个以上的方法名相同，但他们的形参列表不同，则称为方法的重载
重写：子类重写父类的方法,方法名、参数列表和返回类型完全一样public class Overload{ public void test(){ System.out.printLn("无参数方法"); } public void test(String msg){ System.out.printLn("重载方法"+msg); } public static void mian(String[] args){ Overload ol=new Overload(); ol.test(); ol.test("测试"); } } 控制台输出 无参数方法 重载方法测试
- 对象、类、属性、方法
类是对象的抽象、属性是类的特征，对象是类的具体实例
方法是类或对象的行为特征的抽象 - 静态修饰符static
静态变量是被类的所有实例共享的
类名来访问类的变量public class Demo{ private static String name="张三";//静态变量 private String sex; private static int age=12; public Demo(String sex){ this.sex=sex; } //静态方法 public static void age(){ System.out.println(age); } public void info(){ System.out.println(sex); System.out.println(name); } } public class Test{ public static void main(String[] args){ Demo.age(); Demo d=new Demo("男")； d.info(); } } 控制台打出： 12 男 张三 - 构造方法：用来创建实例是执行初始化
public class ITCompany{ private String name; private int age; public ITCompany(){ //无参构造方法 } public ITCompany(String name,int age){ //有参构造方法 this.name=name; this.age=age; } } 注：构造方法不可以用void修饰 - this关键字和super关键字（注：调用构造方法时，不能同时出现。都需要放在首行）
1）、this关键字表示当前对象
this调用当前对象的属性和方法
this调用自身对象的构造方法public class ITCompany{ private int age; public int getAge(){ return age; } public void setAge(int age){ //this调用当前对象的属性 this.age=age; } public ITCompany(){ //无参构造方法 } public ITCompany(String name,int age){ //有参构造方法 //this调用自身对象的构造方法 this.name=name; this.age=age; } }2）、super关键字：表示当前对象的父类引用
调用父类的成员的属性和方法
调用父类的某个特定的构造方法 - final关键字
1）保持父类中的某个方法的操作在被继承是不会发生改变
2）被final修饰的方法，子类不允许重写该方法
3）在一定程度提高该方法的执行速度，在调该方法时，不需要进行覆盖判断 - 抽象类
抽象类主要用于继承，不能被实例化。抽象类的具体子类必须实现抽象类所有的抽象方法
一个类被abstract修饰，该类就是抽象类
某个方法被abstract修饰，该方法是抽象方法
一个类只要有一个抽象方法，该类就是抽象类
抽象类可以有非抽象方法（普通方法） - 接口
- 实例
- 方法：语句的集合
- 循环
//循环while、 do…while、for int a=3,b=5; int i=0; while(a<b){ i++; System.out.println("i:"+ i); if(i==4){ break; } } int x=0; do{ x++; System.out.println("x:"+ x ); if(x==10){ break; } }while( b <10 ); for(int j =0;j < b; j ++) { System.out.println("j : " + j ); } - 运算符：算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符和其他运算符（按其功能，列举常用的）
//算术运算符：+、–、* 、/、%、^、! 、|X| int a=3,b=5; int num=0; //+（加号） 加法运算 num=a+b; System.out.println(num);//8 //–（减号） 减法运算 num=b-a; System.out.println(num);//2 //*（星号） 乘法运算 num=a*b; System.out.println(num);//15 // /（正斜线） 除法运算 num=b/a; System.out.println(num);//1 //%（百分号） 求余运算 num=b%a; System.out.println(num);//2 //^（乘方） 乘幂运算 num=b^a; System.out.println(num);//6 // 求正 Math.abs(变量) num=a-b; System.out.println(Math.abs(num));//2//赋值运算=、*=、/=、%=、+=、–=、<<=、>>=、&=、^=、|= System.out.println("===========赋值运算==============="); int c=3,e=2,f=e; c*=e; System.out.println(c);//6 System.out.println(e);//2 c=c*e; System.out.println(c);//12 System.out.println(f);//2 int d,g=3,h=5; d=h-g; System.out.println(d);//2 d+=g; System.out.println(d);//5 System.out.println(g);//3 d=+g; System.out.println(d);//3 System.out.println(g);//3//逻辑运算符 &与&&、|与||、&&(逻辑与)"， "||(逻辑或)"， "!(逻辑非) int number=2,num1=3,num2=5; if(num2<num1||num1>number){ System.out.println("||满足条件"); } if(num2<num1&&num1>number){ System.out.println("&&满足条件"); } if(!(num2<num1)&&num1>number){ System.out.println("!满足条件"); } - 异常：
java异常处理机制主要依赖于try，catch，finally，throw，throws五个关键字。
//java异常处理机制主要依赖于try，catch，finally，throw，throws五个关键字。 // 语法: // Try{ // 可能出现异常的代码 // }catch(Exception e){ // 出现异常后的处理 // }finally{ // 不管出现异常与否都要执行的代码 // } // Throw是代码需要创建一个异常时的关键字,写在方法体里 // Throws是当前方法会有异常抛出的声明,写在方法签名 - 正则表达式：Java JDK 1.40版本中，自带了正则表达式的包（java.util.regex）
- 时间转换
package org.com.test; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Random; public class Times { public static void main(String[] args) { Calendar cal = Calendar.getInstance(); System.out.println("cal:"+cal); int year = cal.get(Calendar.YEAR); int month = cal.get(Calendar.MONTH) + 1; int day = cal.get(Calendar.DATE); int nowHour = cal.get(Calendar.HOUR_OF_DAY); System.out.println(year); System.out.println(month); System.out.println(day); System.out.println(nowHour); //使用Calendar来获取当前日期和时间 SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss-SSS"); System.out.println("format获取的："+format); String time=format.format(Calendar.getInstance().getTime()); System.out.println(time); SimpleDateFormat format1=new SimpleDateFormat("yyyy-MM-dd"); String time1=format1.format(Calendar.getInstance().getTime()); System.out.println(time1); SimpleDateFormat format2=new SimpleDateFormat("HH-mm-ss-SSS"); String time2=format2.format(Calendar.getInstance().getTime()); System.out.println("time2:"+time2); Calendar calendar = Calendar.getInstance(); System.out.println("Calendar获取的是："+calendar); System.out.println(calendar.getTime()); } } -
BigDecimal的用法
package org.com.test; import java.math.BigDecimal; public class BigDecimalDemo { public static void main(String[] args) { //使用数字构造和字符构造的区别 double num=3.1415; BigDecimal value1=new BigDecimal(num); System.out.println("数字构造："+value1); // 数字构造：3.141500000000000181188397618825547397136688232421875 BigDecimal value2=new BigDecimal(Double.valueOf(num).toString()); System.out.println("字符构造："+value2); //字符构造：3.1415 BigDecimal value =value2.setScale(2, BigDecimal.ROUND_HALF_UP); System.out.println(value); //3.14 //舍入趋向于零的方式 value=value2.setScale(2, BigDecimal.ROUND_DOWN); System.out.println(value); //3.14 //舍入远离零的方式 value=value2.setScale(2, BigDecimal.ROUND_UP); System.out.println(value); //3.15} -
随机数
package org.com.test; import java.util.Random; public class RandomDemo { public static void main(String[] args) { Random random = new Random(); String only=String.valueOf(random.nextInt(6));//6是不包含在内的，只产生0~6之间的数。 String onlysign = String.valueOf(random.nextInt(5)+4);//random.nextInt(5)只产生0~5之间的数（0，1，2，3，4），随机生成4、5、6、7、8 System.out.println(only);//0、1、2、3、4、5 System.out.println(onlysign);//4、5、6、7、8 } }
三、面向对象（继承、封装、多态）
- 继承：
- 封装：就是隐藏对象的属性和实现细节，仅对外提供的公共访问方法（主要采用访问控制修饰符来控制类及类的方法和变量的访问权限，从而向使用者暴露接口，但隐藏实现细节｛Java语言访问修饰符｝）。好处：隐藏了类的实现细节；让使用着只能通过程序员规定的方法访问数据；可以方便的加入存取控制语句，限制不合理操作。
- 多态（重载、重写）
- 接口
- 抽象类
- 枚举
四、知识延伸
- 集合
- 数据库连接：原始数据库连接
public class ConnectDB { public static Connection getConnection() { Connection connection = null; try { Class.forName("com.mysql.jdbc.Driver"); //-----在url后面添加useUnicode=true&characterEncoding=UTF-8这些参数是为了让mysql数据库可以识别中文----- String url = "jdbc:mysql://数据库ip地址/数据库名?useUnicode=true&characterEncoding=UTF-8"; String username = "root"; String password = ""; try { connection = DriverManager.getConnection(url,username,password); System.out.println("数据连接成功！"); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } return connection; } public static void main(String[] args) { getConnection(); } } - 代码的优的目标：提高代码运行的效率，减少代码的体积。（ sql优化、存储过程、视图、连接池；html静态化；不用保存太多的信息在HttpSession中；异常处理；尽可能的使用Java自身提供的API；尽量减少I／O操作（控制台、日志））
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
