Java基础-1 Java基础语法

Java的学习主要分三个阶段,第一个阶段Java基础的学习,第二个阶段Java web技术的学习,第三个阶段企业框架的学习。相比于PHP开发,Java更适合开发一些大型的商业应用系统,因为其安全性和可维护性更高,当然成本也相对较高。另外Java开发主要有web方向和安卓方向,我学习的是Web方向,总结的当然不会有安卓的内容,不过它们核心都在Java基础。
一、了解Java
1、java语言的三种技术架构

J2EE/JavaEE:企业版

是为开发企业环境下的应用程序提供的一套解决方案。

该技术体系中包含的技术如 Servlet、Jsp等,主要针对于Web应用程序开发。

J2SE/JavaSE:标准版

是为开发普通桌面和商务应用程序提供的解决方案。

该技术体系是其他两者的基础,可以完成一些桌面应用程序的开发。比如Java版的扫雷。

J2ME/JavaME:小型版

是为开发电子消费产品和嵌入式设备提供的解决方案。

该技术体系主要应用于小型电子消费类产品,如手机中的应用程序等。
2、JVM、JRE和JDK的区别:

JVM(Java Virtual Machine):Java虚拟机,用于保证Java的跨平台的特性。注意:Java语言是跨平台,Jvm不是跨平台的,不同的系统平台需要安装不同的JRE。 跨平台核心:JVM

JRE(Java Runtime Environment):Java的运行环境,包括jvm+java的核心类库。

JDK(Java Development Kit):Java的开发工具包,包括jre+开发工具
3、环境变量的配置

Java1.5版本以后无需设置classpath,所以一般设置Path路径就可以了。

Path路径:是配置Windows可执行文件的搜索路径,即扩展名为.exe的程序文件所在的目录。

在计算机系统属性-高级系统设置-环境变量下 配置:

JAVA_HOME      盘符:\Program Files\Java\jdk版本号

Path                     %JAVA_HOME%\bin;  在最前面添加,注意不能少分号
4、开发Java程序的步骤:

编码(生成.java的源文件)--编译(生成.class的字节码文件)--执行
二、数据类型与运算符
1、变量的作用

变量的作用:用来存储数据。例子:int money=1000;

为什么要定义变量:用来不断的存放同一类型的常量,并可以重复使用

注意:其值不能改变的量用final常量表示,常量必须大写

如:final int NUM=10;
2、变量命名规则:

首字母:字母、下划线、$、¥  其后可以是: 数字

命名形式:驼峰    使用有意义英文字母

不能使用关键字来自定义命名  比如public class
3、数据类型分类

基本数据类型:使用栈的位置

引用数据类型:引用堆的对象  比如String(是java提供的一个类)  类  数组   接口

8种基本数据类型

整型 byte short int long     浮点型 float double

字符型 char                           布尔型  boolean
4、类型转换

精度从高到低  double  float  long  int  short(char)  byte

自动类型转换:低精度--->高精度,类型兼容

强制类型转换:高精度--->低精度int b=(int)10.3+(int)43.2;
5、运算符基本分类

1、 算数运算符(+ - * / % ++ --)如 :7%4=3 求余运算符;  i++相当于 i=i+1;  ++i 先计算i自加

2、关系运算符(> >= < <= == !=) ==恒等于 != 不等于 如:num1=(10==20) 输出为假 ,用false表示

3、逻辑运算符(|| && ! ) 或 且 非 关系 或:有一个为真就是真

4、位运算符 ( &按位与、|按位或、^按位异或、~按位非、<<左移、>>右移、>>>无符号右移 ) 位运算操作数为整形数,结果int 或long 二进制运算5&6=0

5、条件运算符(? :) 如: 5<7?5:7 结构是ture,执行表达式1 否则表达式2  取最小值的写法

6、赋值运算符(= a+= a*=) 如:x+=3相当于x=x+3    x*=y+8相当于x*
6、运算符优先级

算术>关系>逻辑

算术运算:乘除优先加减

关系运算符: 从左到右计算  >  >=  <  <=  优先级高于 == !=

逻辑运算符:非>且>或   其中”非“高于乘除  ; 遵循括号优先

単目运算符++ ~  --    三目运算符  ? :
三、流程控制
1、程序结构

  • 选择结构:

1、if结构

1、基本if   处理单一或组合条件情况

2、if-else 处理简单条件情况

3、多重if 处理分段条件情况 一定要注意条件顺序!

4、嵌套if 处理复杂条件情况

2、switch:适合多重条件分支,等值条件判断!注意break default

  • 循环结构:

1、while循环     处理多次重复执行的条件

while(条件){

      操作

      循环条件

}

   2、do while 循环

do{

      循环操作

}while(循环条件);

   3、For循环

for(初始化变量;条件判断;更新循环变量){

      循环操作

}

  • 嵌套循环    允许三种语言嵌套

1、外层循环执行一次 → 内层循环执行全部;

2、内层循环全部执行完→进行外层继续操作
2、循环的跳转

break:        跳出整个循环结构                    (用在循环和switch语句)

continue:  跳出本次循环,进入下次循环(用在循环语句中)

return:       直接结束方法
3、程序的调试Debug

设置断点→单步运行→观察变量
四、数组

1、数组定义

占用内存中一串连续的空间,存储相同数据类型的数据。是一个变量,但可以定义多个变量。

如:int[] scores=new int[]{2,34,56举例:,33,2};

2、数组分类

1、一维数组

int[] nums=new int[3];

int rate[4+5];    [数组长度]可以是常量或常量表达式,不能用变量

数组下标:取值范围  0  ~  数组长度-1

数组初始化:int[] scores={2,3,4,5}或者int[] scores=new int[]{2,34,56,33,534,343,2};

数组长度: scores.length

数组遍历  for(int num:scores){}
2、二维数组
——最常见多维数组:

int[][] nums=new int[3][];     最高维 nums.length=3  注意在使用运算符new来分配内存时,对于二维数组至少要给出最高维的大小

int scores[][]={{90,85,45,64,43},{34,54,45}.{35}}  scores[0].length=5

int nums[][]=new int[5][50];   5栈  50堆

对比C语言:

java语言  数组初始化 int num[][]=new int[5][];   初始化外层最高维不可省略  ,内层可以省略

c    语言   数组初始化 int num[][2]={{1,2},{3,4},{5,6},{7,8}}; 初始化行数(外层)可以省略,列数(内层)不可以省略。理解为行列相间的表格,通过嵌套循环访问二维数组,其外层循环控制行数,内层循环控制每行数据内容

3、工具类:Arrays类

1、boolean equals (array1,array2) 比较

2、sort(array) 升序

3、String toString(array) []

4、void fill(array,val) 全部赋值为val

5、copyOd(array,length) 数组复制为新长度数组

6、int binarySearch(array,val) 查询元素值val在数组中的位置(下标)
4、常用排序方法

1、插入排序:直接插入排序、希尔排序

2、选择排序:简单选择排序、推排序

3、交换排序:冒泡排序、快速排序  --主要学习内容

4、归并排序

       5、基数排序
五、相关代码

Code   ViewPrint
  1. package practice  //新建包
  2. import java.util.Arrays;    //导入Arrays类
  3. import java.util.Scanner;   //导入Scanner类
  4. /** 
  5. * @author Visant E-mail: 1206719539@qq.com
  6. * @date 2016年5月5日 下午2:31:40 
  7. * @version 1.0 
  8. */
  9. public class Demo2 {
  10.     public static void main(String[] args) {
  11.     /*//求最大、最小值
  12.         int []a=new int[]{800,4,2,1,-23,344,12,2};
  13.         int max,min;
  14.  
  15.         max=min=a[0];
  16.  
  17.         for(int i=1;i<a.length;i++){
  18.             if(max<a[i]) max=a[i];
  19.             if(min>a[i]) min=a[i];
  20.         }
  21.  
  22.         System.out.println("max="+max+",min="+min);*/
  23. /*      //二维数组书写形式
  24.         int [][]a = new int[3][];
  25.         a[0]=new int[]{1,2,3};
  26.         a[1]=new int[]{4,5,6,7,8};
  27.         a[2]=new int[]{9,0};
  28.     */
  29.         /*//二维数组遍历
  30.         //初始化二维数组
  31.         int [][]a=new int[][]{{1,2},{3,4,5},{6,7}};
  32.  
  33.         for(int i=0;i<a.length;i++){//外层控制进行几次内层循环
  34.             for(int j=0;j<a[i].length;j++){
  35.                 System.out.print(a[i][j]+" ");//内层控制输出遍历的每个数字
  36.             }
  37.             System.out.println();
  38.         }*/
  39.         /*//初始化二维数组
  40.         int [][]array=new int[][]{{80,66},{70,54,98},{77,59}};
  41.         int total;//保存成绩
  42.  
  43.         for (int i = 0; i < array.length; i++) {//外层班级循环
  44.             String str=(i+1)+"班";//定义班级变量
  45.             total = 0;//每次循环到此都归为0
  46.             for (int j = 0; j < array[i].length; j++) {//内层成绩循环相加
  47.                 total += array[i][j];//成绩相加         
  48.             }
  49.             System.out.println(str+"总成绩:"+total);
  50.         }*/
  51.     }
  52. }
  53. public class Demo1 {
  54.     public static void main(String[] args) {
  55. /*Arrays类操作数组:
  56.  * 主要学习equals()、sort()、binarySearch()方法
  57.  * */
  58.     /*  //equals()方法
  59.         int []arr1={10,50,40,30};
  60.         int []arr2={10,50,40,30};
  61.         int []arr3={60,50,85};
  62.         System.out.println(Arrays.equals(arr1,arr2));//判断arr1,arr2长度与元素是否相等
  63.         System.out.println(Arrays.equals(arr1,arr3));//判断arr1,arr3长度与元素是否相等
  64.         //sort()方法排序
  65.         int []a=new int[]{1,3,5,2,8,6};
  66.         Arrays.sort(a);//升序排列
  67.         System.out.println("\n升序排列结果:");
  68.         for(int obj:a){
  69.             System.out.print(obj+" ");}
  70.         //binarySearch()方法
  71.         int []arr={10,50,40,30};
  72.         Arrays.sort(arr);//升序排列
  73.         int index=Arrays.binarySearch(arr, 30);//查找30元素所在的位置-下标
  74.         System.out.println(index);
  75.         index=Arrays.binarySearch(arr, 50);//查找50元素所在的位置-下标
  76.         System.out.println(index);*/
  77. /*常用排序方法:http://blog.csdn.net/pzhtpf/article/details/7559896
  78.  * 1、插入排序:直接插入排序、希尔排序
  79.  * 2、选择排序:简单选择排序、推排序
  80.  * 3、交换排序:冒泡排序、快速排序
  81.  * 4、归并排序
  82.  * 5、基数排序
  83.  * 主要学习:快速选择排序、冒泡排序*/
  84. /* 
  85.  //冒泡降序排列     嵌套循环实现!
  86.         int[] nums={8,46,100,2,0};
  87.         for(int i=0;i<nums.length-1;i++){//i+j=nums.length-1 外层轮数与内层循环次数总和
  88.             for(int j=0;j<nums.length-1-i;j++){
  89.                 if(nums[j]<nums[j+1]){
  90.                     //交换数据
  91.                     int temp=nums[j];
  92.                     nums[j]=nums[j+1];
  93.                     nums[j+1]=temp;
  94.                 }
  95.             }
  96.         }
  97.         //输出结果
  98.         System.out.println("降序排列结果");
  99.         for(int num:nums){
  100.             System.out.print(num+"\t");
  101.         }*/
  102. //冒泡升序排列
  103.         int []a=new int[]{1,3,5,2,8,6};
  104.         for(int i=0;i<a.length-1;i++){//总共进行几轮
  105.             for(int j=0;j<a.length-1-i;j++){//每轮交换次数 int j=i;j<a.length-1;j++
  106.                 if(a[j]>a[j+1]){
  107.                     //交换数据
  108.                     int temp=a[j];
  109.                     a[j]=a[j+1];
  110.                     a[j+1]=temp;
  111.                 }
  112.             }
  113.         }
  114.         System.out.println("\n升序排列结果:");
  115.         for(int obj:a){
  116.             System.out.print(obj+" ");
  117.         }
  118. /*      
  119. //类方法升序排序       
  120.         int []a=new int[]{1,3,5,2,8,6};
  121.         Arrays.sort(a);
  122.         System.out.println("\n升序排列结果:");
  123.         for(int obj:a){
  124.             System.out.print(obj+" ");}
  125. //类方法降序排列
  126.         int []a=new int[]{1,3,5,2,8,6};
  127.         Arrays.sort(a);
  128.         for(int i=0,j=a.length-1;i<j;i++,j--){
  129.             int temp=a[i];
  130.             a[i]=a[j];
  131.             a[j]=temp;
  132.         }
  133.         System.out.println("\n降序排列结果:");
  134.         for(int obj:a){
  135.             System.out.print(obj+" ");}*/
  136.         /*      
  137. //数组添加:   定位。  index==-1插入在最后, index==a,进行倒序移动,前值给后值。输出结果
  138.         int []a=new int[6];//在堆中开辟6个空间
  139.         //接受5个数字的输入,并显示输入结果
  140.         System.out.println("请输入5个升序排列的整数:");
  141.         Scanner input = new Scanner(System.in);
  142.         for(int i=0;i<a.length-1;i++){//注意这里是a.length-1!也就是进行5次循环输入
  143.             a[i]=input.nextInt();
  144.         }
  145.         System.out.println("********插入前**********");
  146.         for(int i=0;i<a.length-1;i++){
  147.             System.out.print(a[i]+" ");
  148.         }
  149.         //进行插入操作
  150.         System.out.println("\n请输入要插入的元素:");
  151.         int num=input.nextInt();
  152.         //比较大小进行定位
  153.         int index=-1;//定义插入数组的位置变量
  154.         for(int i=0;i<a.length;i++){//进行6次循环比较
  155.             if(num<=a[i]){
  156.                 index=i;//如果插入数字小于某个数字,则其位置给a[index]
  157.                 break;
  158.             }//否则index值不变
  159.         }
  160.         //显示插入后结果
  161.         if(index==-1){//插入在最后
  162.             a[a.length-1]=num;
  163.         }else{
  164.             //确定插入,则其他数字后移
  165.             for(int i=a.length-2;i>=index;i--){
  166.                 a[i+1]=a[i];//倒序移动,前值给后值
  167.             }
  168.             a[index]=num;
  169.         }
  170.         System.out.println("******插入后*************");
  171.         for(int obj:a){
  172.             System.out.print(obj+" ");
  173.         }
  174.  
  175.  
  176. //数组修改
  177.         int indexNew=-1;
  178.         System.out.println("\n请输入要修改的元素:");//提示修改
  179.         num=input.nextInt();
  180.         for(int i=0;i<a.length;i++){
  181.             if(num==a[i]){
  182.                 indexNew=i;//找到了要修改的数字
  183.                 break;
  184.             }
  185.         }
  186.         if(indexNew!=-1){  //找到了要修改的
  187.             System.out.println("请输入要修改为:");
  188.             num=input.nextInt();
  189.             a[indexNew]=num;
  190.             System.out.println("*********修改后************");
  191.             for(int i=0;i<a.length;i++){
  192.                 System.out.print(a[i]+" ");
  193.             }
  194.         }else{
  195.             System.out.println("没有找到要修改的元素");
  196.             System.out.println("*********修改后************");
  197.             for(int i=0;i<a.length;i++){
  198.                 System.out.print(a[i]+" ");
  199.             }
  200.         }
  201.  
  202. //数组删除:  定位 。 index==-1没有找到无法删除, index==a,进行正序移动,后值给前值。输出结果
  203.         System.out.println("\n请输入要删除的元素:");//提示删除
  204.         num=input.nextInt();
  205.         //比较定位
  206.         index=-1;
  207.         for(int i=0;i<a.length;i++){
  208.             if(num==a[i]){
  209.                 index=i;//如果找到要删除数字,则其位置给啊a[index]
  210.                 break;
  211.             }
  212.         }
  213.         //进行删除前移操作
  214.         if(index!=-1){  //不是-1,就是找到了要删除的
  215.             for(int i=index;i<a.length-1;i++){
  216.                 a[i]=a[i+1];//正序移动,后值给前值
  217.             }
  218.             System.out.println("*********删除后************");
  219.             for(int i=0;i<a.length-1;i++){
  220.                 System.out.print(a[i]+" ");
  221.             }
  222.         }else{
  223.             System.out.println("没有找到要删除的元素");
  224.             System.out.println("*********删除后************");
  225.             for(int i=0;i<a.length;i++){
  226.                 System.out.print(a[i]+" ");
  227.             }
  228.         }*/
  229.         /*
  230. //遍历数组
  231.         int scores[]=new int[5];
  232.         Scanner input=new Scanner(System.in);
  233.         System.out.println("请输入5个整数");  //循环遍历输入5个数
  234.         for(int i=0;i<scores.length;i++){
  235.             scores[i]=input.nextInt();
  236.         }
  237.         System.out.println("输入的数字为:");//显示输入结果
  238.         for(int i=0;i<scores.length;i++){
  239.             System.out.print(scores[i]+" ");
  240.         }*/
  241.         /*      
  242. //增强for循环
  243.         int scores[]={75,67,90,100,0};
  244.         for(int i:scores){
  245.             System.out.println("数组元素依次为:"+i);
  246.         }*/
  247.     }
  248. }
Visant

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: