------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
软件概念
一系列按照特定顺序组织的计算机数据和指令的集合
软件的出现实现了人与计算机之间更好的交互。
交互方式：图形化界面和命令行方式
DOS命令行常见命令：
dir : 列出当前目录下的文件以及文件夹
md : 创建目录
rd : 删除目录
cd : 进入指定目录
cd.. : 退回到上一级目录
cd/ : 退回到根目录
del : 删除文件
Java语言是SUN(Stanford University Network，斯坦福大学网络公司)1995年推出的一门高级编程语言，是一种面向对象的编程语言。exit : 推出dos命令行
Java语言特点：
简单易学，完全面向对象，安全可靠，与平台无关（跨平台性）。
Java语言的三种技术架构：
1、Java EE（Java Enterprise Edition)企业版
2、Java SE（Java Standard Edition）标准版
3、Java ME（Java Micro Edition）微型版
Java中常用名词：
API（applicationprogram interface）应用程序接口：为开发Java程序而预定义的类或接口。
JRE(JavaRuntime Environment )Java运行环境：包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库
JDK(JavaDevelopment Kit) Java开发工具包：JDK是提供给Java开发人员使用的，其中包含了java的开发工具，也包括了JRE，用于开发和测试Java程序。
Java环境变量配置：
JAVA_HOME= D:\jdk1.7.0 JAVA_HOME指向JDK的安装路径
PATH=%JAVA_HOME%\bin;%PATH% %PATH%引用以前设置的PATH环境变量
CLASSPATH=.\;%JAVA_HOME%\lib\tools.jar 实现在任意目录下都可以执行某一目录下的class文件
Java基础语法
关键字
被java赋予特殊含义的的单词。
特点：其中的所有字母均为小写。特殊：main不是关键字，但是虚拟机可识别
标识符
在程序中自定义的一些名称
规则:
由26个英文字母大小写，0~9数字，下划线（_），美元符号（$）组成。
数字不能开头不能使用关键字java严格区分大小写java中的名称规范：包名：所有单词都小写类名、接口名：所有单词首字母大写变量名、函数名：多单词组成时，第一个单词字母小写，第二个单词开始首字母大写常量名：所有字母都大写
注释：用于注解说明解释程序的文字
好处：提高代码的阅读性
注释格式：
单行注释： //注释文字
多行注释： /*注释文字*/
常量与变量文档注释： /**注释文字*/
常量：不能改变的数值
分类：整数常量 小数常量 布尔常量 字符常量 字符串常量 null常量（只有一个数值null）
变量：用来不断存放同一类型的常量，并可以被重复使用
格式：数据类型 变量名=初始化值;
理解：变量就如同数学中的未知数
Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空间
整数默认：int 小数默认：double
byteb1=128;//会报错 byte类型范围：-128~127
long l=4l;//4l中的l标示是long数据类型
floatf=2.3f;// 单精度float定义变量时用f标识
doubled1=2.3;//一般默认是double类型
char ch1='';
charch2='a';
charch3='+';
charch4='4';//char只能定义单个字符
char ch5='你';//一个汉字两个字节 char类型也是两个字节
booleanbo1=true;
booleanbo2=false;
字符串数据和任何数据使用+都是相连接，最终都会变成字符串
System.out.println("5+5="+5+5);//结果5+5=55
System.out.println("5+5="+(5+5));//结果5+5=10
类型转换
自动类型转换（隐式类型转换）强制类型转换（显式类型转换）
System.out.println('a'+1);//结果98 字符'a'在计算过程中由于默认int 1被强制转换成97
System.out.println((char)('a'+1));//结果b
System.out.println('A'+1);//结果66
System.out.println('1');//结果1
System.out.println("A="+'A');//A=A
System.out.println('1'+0);//结果49 同理 字符‘1’被强制转换
System.out.println((char)(4));//结果是方块
inty=4364;
System.out.println(y/1000*1000);//结果4000，y/1000后抢注转换成4在乘以1000
System.out.println(-1%2);//结果-1
System.out.println(1%-2);//结果1 求余数运算只看被模数
byte b=2;
b=b+3;// 会报错，b+3结果为int型强制赋值给b(byte)类型
b=++b;//不会报错，++b是一次运算，包含了一个隐藏的类型转换
自增和自减(++ --)
inta=3,c,d;c=a++;System.out.println("a="+a+",c="+c);//结果a=4,c=3d=++a;System.out.println("a="+a+",d="+d);//结果a=5,d=5/*两种自增运算中a的值都会变化，a++相当于先把a的值赋给c,然后进行加1++a相当于先自己加1,然后赋给d */
赋值运算 += -= *= /= %=
shorts=4;/*s=s+5;编译失败 5默认是int类型，s+5的值int类型无法赋值给short型两次运算 先做加法 在把值赋给左边*/s+=5;//一次运算 自动把s+5的值赋给s
比较运算符 == != < > <= >= instanceof
Instanceof 检查是否是类的对象例如： helloinstanceof String 结果为true注意：比较运算符的结果都是boolean类型 要么是true，要么false
逻辑运算符 &(与) |(或) ^(异或) !(非) && ||
用法：逻辑运算符用于连接boolean类型的表达式true^true=false;true^false=true; ^：两边相同结果为falsefalse^true=true; 两边不同结果为truefalse^false=false;&: 无论左边是true或者false，右边都运算&&:当左边为false时，右边不运算|: 两边都参与运算||:当左边为真时，右边不运算
位运算符(二进制运算)
<<左移 >>右移 >>>无符号右移 &与 |或 ^异或 ~反码
<<:乘以2的移动的位数次幂,空位补0
2乘以8最有效率的方式：2<<3
>>:除以2的移动的位数次幂。最高位补什么由原数据的最高位决定
如果最高位为0，右移后用0补空位如果最高位为1，右移后用1补空位
>>>:无论最高位是什么，右移后，都用0补
6&3=2 即110&011=0106|5=7 即110|101=1116^5=3 即110^101=011 6^5^5=6
~:按位取反
一个数异或同一个数两次，结果还是那个数 常用于数据加密
两个数进行交换方法：三种int n=3,m=8;
int temp;第一种：(最常用)
temp=n;
n=m;m=temp;
n=n+m;第二种：
m=n-m;
n=n-m;
n=n^m;第三种：
m=n^m;
n=n^m;
三元运算符
格式：(条件表达式)?表达式1:表达式2如果条件为true ，运算后的结果取表达式1如果条件为false，运算后的结果取表达式2
例题：将整数60转为十六进制思路：1：获取60的最低四位，通过&15 即&1111
2：将60右移四位，以便获取下一组四位
3：获取右移四位后的数的最低四位，通过&15
int num=60;int n1=num&15;
System.out.println((n1>9)?(char)(n1-10+'A'):n1);/*n1结果为67 预想结果为C 原因是因为n1为整数类型，在与char运算是自动切换成整数了 */
intn2=num>>>4;//用>>>而不用>>是为了取尽所有的二进制数
intn3=n2&15;
System.out.println((n3>9)?(char)(n3-10+'A'):n3);
程序流程控制
判断结构
1.If(){} 2.if(){} else{} 3.if(){} else if(){}…else{}三种格式
if else结构 简写格式：变量=(条件表达式)?表达式1:表达式2三元运算符： 好处：可以简化if else代码
弊端：运算符运算完成必须要有一个结果而if else语句可以不需要结果
格式：选择结构（switch）
switch(表达式){//表达式类型四种 byte short int char
case 取值n：}
执行语句;
break;
...
default：
执行语句;
break;//可以省略
1、switch语句中表达式只有四种：char，int，byte，short，当具体数比较少时用switch；
2、default的位置不固定，进入switch语句后，从第一个case开始读，当所有的case都不满足时才读default；
3、switch语句结束有两种方式。第一种：当读到满足条件case的break；第二种：读到switch的大括号
y=7;
switch(y){
default:
System.out.println("e");
case 2:
System.out.println("a");
case 3:
System.out.println("b");
//break;
case 4:
System.out.println("c");
break;
case 5:
System.out.println("d");
}结果为：eabc
执顺序为：case2，case3，case4，case5，发现都不满足条件，又没有遇到break，则继续读default，打印e，既没有遇到break，又没有遇到大括号，
又往下读case2，case3，case4，遇到break，跳出循环
if和switch区别：
当判断的具体数值不多，且符合byte short int char四种类型 用switch语句 效率高对于区间判断，对结果为boolean类型进行判断,使用if语句，if语句的使用范围广。
循环结构代表语句：while，do while，for
while特点：先判断条件，只有条件满足才执行循环体
dowhile特点：条件无论是否满足，循环体都至少被执行一次
for(初始化表达式,循环条件表达式,循环后的操作表达式){执行语句;}
for的循环条件表达式必须为boolean类型
for表达式不唯一，多表达式用，隔开
for与while的区别：
(1)变量有自己的作用域，对于for来讲，如果将用于控制循环的增量定义在for语句中，那么该变量只在for语句内有效，for语句执行完毕，该变量在内存中被释放；(2)for和while可以互换，如果需要定义循环增量，用for更为合适；当要对某些语句执行很多次时，就使用循环语句；
无限循环的最简单表达式：
(1)for(,,){} //对于for来说，不写循环条件表达式，默认为true
(2)while(true){}
break和continue的使用
标号即xx: 给循环起名 可以让break和continue语句作用于指点的范围
haha:for(int e=1;e<3 ;e++ )
{
xixi:for(int r=1;r<4;r++ )
{
System.out.println("e="+e);
//break; //e=1 e=2
breakhaha;//e=1打印一次即跳出循环
}
}
打印10以内的偶数
for(int e=1;e<=10 ;e++)
{
if(e%2==1)
continue;
System.out.println("e="+e);//24 6 8 10
}
break应用范围：选择结构和循环结构
continue只作用于循环结构 继续循环 特点：结束本次循环，继续下一次循环
break和continue单独存在时，下面不可以有任何语句，因为执行不到
break和continue这两个语句离开应用范围，存在是没有意义的
打印10以内的偶数
for(int e=1;e<=10 ;e++)
{
if(e%2==1)
continue;
System.out.println("e="+e);//24 6 8 10
}
打印长方形
外循环控制行数，内循环控制每一行的列数
尖朝上，可以改变内循环条件，让条件随着外循环变化尖朝下，可以初始化内循环值，让初始化随着外循环变化
//九九乘法表
for(int e=1;e<=9 ;e++ )
{
for(int r=1;r<=e;r++ )
{
System.out.print(r+"*"+e+"="+r*e+'\t');
}
System.out.println();
}
函数
函数是指定义在类中的具有特定功能的一段独立小程序, 函数也称方法
函数的格式
修饰符 返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2，...）
{
执行语句;
return 返回值；
}
定义函数：
1、先明确该函数的运算结果，确定返回值类型
2、明确在定义该功能时是否需要未知的内容参与运算
void：当函数运算后没有具体的返回值类型时，用void来标示
当函数的返回值类型为void时，函数中的return可以省略不写
函数的特点：定义函数可以将功能代码进行封装便于对该功能进行复用函数只有被调用才会被执行函数的出现提高了代码的复用性函数中只能调用函数，不可以在函数中定义函数函数重载：
特点：与返回值类型无关，只看参数列表在同一个类中，允许存在一个以上的同名函数，只要他们的参数个数或者参数类型不同
好处：方便阅读，优化程序
eg：int add(int x,int y){return x+y;}
intadd(int x,int y,int z){return x+y+z;}
doubleadd(double x,double y){return x+y;}
数组
数组是同一种类型数据的集合，是一个容器，是引用类型
格式：
格式1：元素类型[] 数组名=new 元素类型[元素个数或者数组长度];
格式2：元素类型[] 数组名=new 元素类型[]{元素1，元素2，...};
内存结构
java程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，每一片区域都有特定的处理数据方式和内存管理方式。
栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。
堆内存： 数组和对象，通过new建立的实例都存放在堆内存中。每一个实体都有内存地址值,实体中的变量都有默认初始化值实体不在被使用，会在不确定的时间内被垃圾回收器回收
方法区：存放JVM加载的类型信息。包括: 类型基本信息，常量池，字段信息，方法信息，类变量，指向ClassLoader的引用，Class类的引用，方法表等。
本地方法区，寄存器
数组定义
一维数组：int[] x; int x[];
二维数组：int[][]; int y[][]; int[] y[];
*int[]x,y[]; //x是一维 y是二维// int[] x;int[] y[];
数组的好处：自动给数组中的元素编号数组的特点：1.长度固定，一旦被创建它的长度就是不可改变的；2.其元素类型必须是相同类型，不允许出现混合类型；3.数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型；4.数组变量是引用类型，数组也可以看做是对象，数组中的每个元素相当于该对象的成员变量，数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组本身是在堆中的。
数组的下标合法区间是[0,length-1]数组的拷贝：System.arrayCopy（源数组，从哪开始，目标数组，从哪开始贴，粘几个）获取数组的长度：数组.length，如a.length；a[0].length，表示获取二维数组中第一个数组的长度。数组的遍历：可以使用for循环戒者for嵌套循环（对于二维数组） ，也可以使用增强for循环来对数组进行遍历，增强for循环格式： for（变量类型 变量名：被遍历的数组）
数组中常见操作：
//打印数组元素 并用逗号隔开
publicstatic void printArray(int[] arr)
{
for(intx=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]);
}
}
//求数组最值
publicstatic int getMax(int[] arr)
{
intmax=arr[0];
for(intx=1;x<arr.length;x++)
{
if(arr[x]>max)
max=arr[x];
}
returnmax;
}
//选择排序法 内循环结束一次，最值出现在头角标位置上
publicstatic void selectSort(int[] arr)
{
for(intx=0;x<arr.length-1;x++){
for(inty=x+1;y<arr.length;y++){
if(arr[x]>arr[y]){
/*
inttemp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
*/
swap(arr,x,y);
}
}
}
}
//冒泡排序法 相邻两个元素进行比较，如果符合条件换位
//第一圈：最值出现在最后位
publicstatic void bubbleSort(int[] arr)
{
for(intx=0;x<arr.length-1;x++){
for(inty=0;y<arr.length-x-1;y++){
if(arr[y]>arr[y+1])
{
/*
inttemp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
*/
swap(arr,y,y+1);
}
}
}
}
//交换数组中两个元素的位置
publicstatic void swap(int[] arr,int x,int y){
inttemp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
查找 获取key第一次出现在数组中的位置，如果返回值为-1，则key在数组中不存在
折半查找
提高效率 但必须保证该数组是有序数组
publicstatic int halfSearch(int[] arr,int key){
intmin=0,max=arr.length-1,mid;
mid=(min+max)/2;
while(arr[mid]!=key){
if(arr[mid]<key)
min=mid+1;
elseif(arr[mid]>key)
max=mid-1;
if(min>max)
return-1;
mid=(min+max)/2;
}
returnmid;
}
//折半查找第二种判断循环条件
publicstatic int halfSearch_2(int[] arr,int key){
intmin=0,max=arr.length-1,mid;
while(min<=max)
{
mid=(min+max)>>1;//右移一位 即除以2
if(arr[mid]>key)
max=mid-1;
elseif(arr[mid]<key)
min=mid+1;
else
returnmid;
}
return-1;
//如果返回return min;则表示在数组中插入一个数，返回min就表示插入的位置
}
//查表法 将所有的元素临时存储起来 建立对应关系
//十进制转换成十六进制
publicstatic void toHex(int num)
{
char[]chs={'0','1','2','3',
'4','5','6','7',
'8','9','A','B',
'C','D','E','F'};
char[]arr=new char[8];
intpos=arr.length;
while(num!=0)
{
inttemp=num&15;
arr[--pos]=chs[temp];//--pos是为了将&15以后的结果倒着存在数组中
num=num>>>4;
}
for(int x=pos;x<arr.length ; x++)//x=pos是为了取十六进制中的有效位 前面的0都省略
{
System.out.print(arr[x]);
}
System.out.println();
}
//十进制转换成其他进制方法一般方法
publicstatic void trans(int num,int base,int offset)
{//base表示转换成其他进制是的单位 offset表示右移位数
if(num==0)
{
System.out.println(0);
return;
}
char[]chs={'0','1','2','3',
'4','5','6','7',
'8','9','A','B',
'C','D','E','F'};
char[]arr=new char[32];
intpos=arr.length;
while(num!=0)
{
inttemp=num&base;
arr[--pos]=chs[temp];
num=num>>>offset;
}
for(int x=pos;x<arr.length ; x++)
{
System.out.print(arr[x]);
}
System.out.println();
}
//十进制转换成二进制
publicstatic void toBin(int num)
{
trans(num,1,1);
}
//十进制转换成八进制
public static void toBa(int num)
{
trans(num,7,3);
}
//十进制转换成十六进制
public static void toHex(int num)
{
trans(num,15,4);
}}
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
