java总结1

J2ee-企业版
J2ME-移动/嵌入式
J2SE-标准版
JDK环境变量配置
JAVA_HOME:JDK的安装路径
path:%JAVA_HOME%\bin
classpath: .;%JAVA_HOME%\lib;%JAVA_HOME%\lib\dt.jar;
上面的点，代表当前路径。
编译:javac 文件名.java
运行 java 文件名
程序源代码-编译器-字节码-JVM（java虚拟机)-01010101两进制-计算机
Java应用领域
语言基础、JDBC、I/O、网路通信
1.明确自己的学习目标和大的方向
2.初学者不要看太多的书
3.了解设计模式
4.不要死记语法
5.多实践，多思考，多请教
6.多查阅资料
7.多阅读别人的源代码
API：application programming Interface 应用程序接口
java：简单，面向对象，分布式，可移植性，解释性，安全性，健壮性，多线程，高性能，动态，反射机制。
1.准备一个JDK，JDK1.6以上
2，安装目录，不能有中文，不能用空格。
3，JDK环境配置
JAVA_HOME:jdk的安装路径
path：%JAVA_HOME%\bin
classpath：.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\dt.jar
CMD命令；
cd 切换目录
cd .. 返回上一级
java程序注释
/**
文档注释
*/
/*
多行注释
*/
//单行注释
编译：javac -d 字节码地址 源文件地址\类名.java
运行:java -pc 字节码地址 类名
变量：变化的量，存储数据
数据类型：8种数据类型
alt+tab键 切换程序界面
数据类型 返回值 大小
boolean 布尔 1
char 字符 2
byte 字节 1
short 短整 2
int 整型 4
long 长整型 8
float 单精度 4
double 双精度 8
数据类型 分装类
float Float
long Long
double Double
char Character
int Integer
数据类型转化
大转小 强制类型转化
小转大 自动类型转化
类名：每个单词首字母大写，不要和系统名重名。
变量名：第一个单词要小写，其他单词首字母大写，尽量让变量名有意义.
*****************************************************************

运算符
1.算术运算符
+ 加
- 减
* 乘
/ 除
% 求余
++ 递增
-- 递减
+= 相加并赋值
-= 相减并赋值
*= 相乘并赋值
/= 相除并赋值
%= 求模并赋值
-取负数
2.关系运算符
> 大于
< 小于
==等于
>= 大于等于
<= 小于等于
！=不等于
3.逻辑运算符
& 逻辑与
| 逻辑或
^ 逻辑异或
！逻辑反
|| 短路或
&& 短路与
4.位运算符
~ 按位非
& 按位与
！按位或
^ 按位异或
>>右移
>>>右移，左边空出的位数0填充;
<<左移
&=按位与赋值
|=按位或赋值
^=按异或赋值
>>=坐移赋值
>>>=右移赋值，左边空出的位数0填充
<<=左移赋值
三元运算符
（表达式？表达式1:表达式2)
流程控制
1.条件语句
if -else
if(条件)
单个语句
else
单个语句
if(条件)
{
语句组
}
else
{
语句组
}
2.switch（表达式)
{
case values
}
循环语句
for(初始表达式;判断表达式;递增表达式){
for循环主体
}
while(条件表达式){
循环主体
}
中断
break;
跳转语句
continue;
********************************************************
其三

数组的存储
byte[] array;声明数组，只能存放byte类型的数组;
short[] array;声明数组，只能存放short类型的数组;
int[] array;声明数组，只能存放int类型的数组;
double[] array;声明数组，只能存放double类型的数组;
char[] array;声明数组，只能存放char类型的数组;
string[] array;声明数组，只能存放string类型的数组;
数组的初始化
第一种数组的创建;
int[] array=new int[10];
创建一个int类型的数组，数组长度是10；
第二种数组的创建;
int array[]=new int[10];
创建一个int类型的数组，数组长度是10；
第三种数组的创建;
int[] array={12,23,44,2,45};
创建一个int类型的数组，并给予值;

数组的访问
创建一个数组 int[] arrray={1,2,34,3,3,2};
访问第一个元素 array[0];

数组的长度
创建一个数组 int[] array={2,32,3,2,1,15,3};
求数组array的长度 array.length
*************************************************************
排序算法笔记
实际问题--抽象问题--代码
算法=计算方法 排序和查询
交换法
定义两个变量
int i1=45;
int i2=54;
/*交换i1,i2*/
int temp=i1;
i1=i2;
i2=temp;
/*交换i1，i2*/
i1=i1+i2;//99
i2=i1-i2;//99-54=45
i1=i1-i2;//99-45=54
/**排序-第一种*/
for(int j=0;j<array.length;j++)
for(int i=j+1;i<array.length;i++)
if(array[j]<array[i])//第一个数小于i位置的数，交换位置
/*交换i1,i2*/
int temp=array[j];
array[j]=array[i];
array[i]=temp;
/**排序-第二种*/
for(int j=0;j<array.length;j++)
for(int i=0;i<array.length-1;i++)//10 9
if(array[i]<array[i+1])
/*交换i1,i2*/
int temp=array[i+1];
array[i+1]=array[i];
array[i]=temp;
/**排序-第二种-高效*/
for(int j=1;j<array.length;j++)
for(int i=0;i<array.length-j;i++)
if(array[i]<array[i+1])<br>
/*交换i1,i2*/<br>
int temp=array[i+1];
array[i+1]=array[i];
array[i]=temp;
/**二分法查找-前提条件：排好序的数*/
/**包：java.lang.*;lang包自动导入，不需要人工导入
public static void search(){
int[] array={1,2,3,4,5,6,7,8,9};//9个数
int random=23456789;//找到random在array中的下标
int low_index=0;
int high_index=array.length-1;
//一直找，直到找到，或找不到为止--for-有明确个数的时候使用
int i=-1;
while(low_index<=high_index){
int midd_index=(low_index+high_index)/2;
if(array[midd_index]==random){
i=midd_index;
System.out.println("index："+midd_index);
break;
}
if(array[midd_index]<random){
low_index=midd_index+1;
continue;
}
if(array[midd_index]>random){
high_index=midd_index-1;
}
}
System.out.println("index:"+i);
}
/**方法
public-公共的 访问限定符
static-静态的 修饰符
void- 空 返回类型
main- 方法名称 主方法
（）- 参数列表（形参列表）
{} - 方法体

返回类型：方法如果返回类型不是void，一定要写return
return-不要将代码放到不可能执行到的位置--无法访问的语句
方法名称：命名规则-第一个单词小写，后面的单词第一个字母大写
第一个字符：$ _ 字母
其他字符：$ _ 字母 数字
尽量起名有意义
/递归 stack-栈 内存溢出/内存不够
//1、自己调用自己的递归
//递归:方法的调用实现了一个循环-解决复杂的规律问题-占内存
*[访问限定符][修饰符] 返回类型 方法名 （形参（参数列表））{方法体}
* void a(){}
* 继承-父类和子类
* 祖宗：Object 所有类默认继承自Object
* java——类都是单继承
* 子类可以得到父类的属性与方法
* @author Administrator
* 访问限定符：
* public:任意类可以使用
* protected:本包可以访问，不通包子类可以使用
* default（friendly）:同一个包可以使用
* private:只有本类可以访问
* 重写与多态 重载：方法名称一样，参数列表不同，其他无关
* 重写： 子类重写父类方法 方法名与参数列表一样
* 访问限定符：子类>=父类 返回类型：子类<=父类
* 异常：子类的异常时父类可识别的
* 多态：多种形态
* 前提：
* 父子类
* 重写
* 父类引用指向子类对象
* 字符串类：String-char[]
* 判断两个对象是否相等：equals