Java基础

####Java名词
+ （JVM）Java虚拟机：Java Virtual Machine
+ 垃圾回收机制：Garbage Collecton
+ JDK：Java Development KIt
+ SDK：Software Development Kit
+ JRE：Java Runtime Environment




####Eclipse 快捷键
1.ctrl+n (打开新建窗口)
2.alt+enter(打开项目属性窗口)
3.ctrl+f11 (快速运行项目)
4.alt+/ (出现提示)
5.ctrl+alt+上下箭头(快速复制)
6.alt+上下箭头(快速移动)
7.ctrl+d （快速删除)




####Java 中的注释
1.文档注释(包、类的上面，方法、属性的上面)
   /**被注释的内容*/
2)单行注释(建议应用在方法内部注释某条语句)
   //被注释的内容
3.多行注释(建议应用在方法内部注释多条语句，或     注释整个方法)
  /*被注释的内容*/




####Java 标识符
**程序员对程序中各个元素命名时使用的字符序列，标识符要遵循以下规则：**
1.由字母，下划线，$,数字组成
2.不能以数字开头
3.不能是Java中的关键字




**标识符的应用原则：**
1.所有的包名都小写
   package com.tarena.tmooc.activity;
2)类名的每个单词首字母大写，其它字母小写。
   class MainActivity{}
3.变量名，方法名第一个单词首字母小写，其它单      词首字母大写。
```


   public void onClick(){}
   int   studentAge;
```


4.所有常量名，都大写。
```


  final double PI=3.1415926;
```


####变量的作用域
变量定义的位置就决定了变量的作用域(作用范围)。
变量按作用域划分的话可以分为:
1.实例变量（类内部，方法外部，没有static修饰）
2.类变量（类的内部，方法外部，有static修饰)
3.局部变量(方法代码块中定义的变量)
4.参数变量(方法参数列表中定义的变量)




**java中变量必备三要素：类型，名称，作用域**




####变量的类型(8种基本数据类型);
1.数值型（整型，浮点型）
整型(byte,short,int,long)
浮点(float,double)
2.字符型(char)
3)布尔型(boolean)
说明：变量的类型决定了变量的取值范围。








**基本数据类型的默认值**




**转义字符**




####变量的类型转换(自动类型转换，强制类型转换)










  byte t1=100;
  int n1=t1;(字节型转换为整型)
  byte t2=(byte)n1; (整型转换为字节型)




  表示范围小的赋值给表示范围大的，例如
  float f1=n1; (自动类型转换)：
  表示范围大的赋值给表示范围小的，例如
  int n2=(int)f1;(强制类型转换)
  说明：强制类型转换可能会出现精度损失。




####Java 中的运算符




1.算术运算符(+,-,*,/,%,++,--)
2.赋值运算符(=,+=,-=,*=,/=,...)
3.关系运算符(>,>=,<,<=,==,!=)
4.逻辑运算符(&&,||,!)
5.条件运算符(? :)三目运算符
6.位运算符(&,|,~,^)
7.移位运算符(>>,<<,>>>)




** 位运算符(&,|,~,^)**
（二进制运算）
+ (&(位与 两个都为1结果为1)
+ |（位或 只要有1个1结果为1）
+ ^（异或运算 相同为0不同为1）
+ ~（位非运算取反，原码取反时符号位不变）)
** 移位运算符(>>,<<,>>>)**
主要快速除法或快速乘法,右移2位相当于除以2，左移以为相当于乘以2
+ <<，>>带符号的移位,符号位不变
+ ( >>>), 不带符号的移位，左边永远补0。
+ 对于正数而言补码和原码相同
+ 对于负数而言补码等于原码取反加1；




####算术符的优先级








####Java 中表达式类型的提升
```


byte t1=10;
byte t2=t1+10;//错
int t2=t1+10;对
byte t3=(byte)(t1+10);对




```


当多个数据参与预算时，遵循以下规则：




1.有一个数据为double,结果则为double.
2.有一个数据为float,结果为float
3)有一个数据为long,结果为long
4)其它都为int
####递归调用




```
     public   static   void  main(String[]  args ) {
        
        System. out .println( sum (100));
    }
     public   static   int  sum( int   sum ){
         if ( sum ==1){            
             return   sum ;
        } else {
             return   sum += sum ( sum -1);
        }     }   


//此程序求100以内所以数字之和
```
####Java 中的语句结构




1.顺序结构（所有语句从上到下依次执行）
2.分支结构 (语句按判断条件执行)
+ if(布尔表达式){}
+ if(布尔表达式){} else{}
+ if(布尔表达式){} else if（布尔表达式）{}else if....
+ switch(表达式)｛case 值1,....;defaut:....｝




3.循环结构（多条语句可以循环执行）




** for(初始化表达式;布尔表达式;迭代操纵){循环体}**
+ 初始化表达式(执行1次，可以放在for上面)
+ 布尔表达式(执行1次或多次，返回为true，执行循环体）
+ 迭代操作（执行0次或多次，循环体执行结束以后执行）
+ 循环体(执行0次或多次)




**while 循环： while(布尔表达式){循环体}**
+ 初始化表达式
+ 布尔表达式
+ 循环体
+ 迭代操作




**do while循环:  do{循环体}while(布尔表达式)**
+ 初始化表达式
+ 布尔表达式
+ 循环体 （先执行循环体，至少要执行1次)
+ 迭代操作




**break，continue，return语句在循环中的应用**


1.不带标号
+ break:退出当前循环
+ continue:退出当前循环的本次，而执行下一次




2.带标号
+ break:退出带标号的循环
+ continue:退出当前循环的
本次循环而执行带标号的下一次循环。




3.return 直接结束方法
####Java新特性  可变参数& foreach方法
返回值类型 方法名称（类型...参数名称){}
 for(数据类型 变量名称：数组名称){
     ...
 }  




**例如**
```
  public   static   void  demo( int  [] array ){
      for ( int   x : array ){
         System. out .println( "循环输出x=" + x );
     }  }   
```
####函数
**函数的概念**
函数是对特定功能代码块的封装，以实现 代码的重复利用，简化程序的编写。




**函数的定义**




语法：[修饰符] 返回值类型 方法名 （参数列表){}
例如:
```


public static void method01(){}
public static int sum(int a,int b){
     return a+b;
}
```


函数签名:函数名+参数列表




**说明：**
1.当函数的返回值类型为void时，函数可以不返回任何值。
2.当函数的返回值类型不为void时，函数体中需要显式指定一个return语句，返回一个与具体返回值类型相对应的一个值。




**函数的调用**




1.指定方法名字
2.函数的参数传递(实际参数传递给形参)
3.函数的返回值(返回给调用处)




**函数的重载**




重载函数是对功能相似代码块的一些定义。重载函数要求函数名字相同，参数列表不同(参数个数，顺序，类型)
说明：重载与方法的返回值类型没有关系
```


int sum(int a,int b){return a+b;};
int sum(int a,int b,int c){return a+b+c;}
int sum(int b,int c){return b+c;}与第一个相同
float sum(int b,float c){return b+c;}
double sum(float c,int b){return b+c;}
```










####数组




**数组的概念**




数组是内存中一块连续的区域用于存储多个类型相同的数据。




例如
1.一个人多门成绩
2.多个人的多门成绩
```


int score1=100;
int score[]={100,90,99};
int score[][]={{100,80,99},{100,90,99}}
```






**数组的维度**
1.一维数组
2.多维数组（一维数组中的数组）




**一维数组变量的定义**
```


int a [];
int[] b; 推荐
int[] b,c;
char[] c;
```






说明：此时并没有构建数组，而是构建了一个数组类型的变量。




**数组类型变量的初始化**




1.定义的同时初始化
+ 静态初始化：
```


    int[] a={1,2,3,4}; (只能用在定义时) 
   int b[]; b={1,2,3,4};错误
```


+ 动态初始化：
```


   int[] c=new int[3];
   int[] c[3]=new int[3];错误
```


2.先定义再初始化
+ 静态初始化：不允许
+ 动态初始化：
```


   int m[]; m=new int[3];
```


3.数组的长度及相关元素的访问？




数组的长度是数组中元素的个数，数组一旦创建其大小(长度)是不能改变的。
数组中元素的访问需要借助下标，下标值从0开始到长度减一结束。




















**1.冒泡排序**




算法：
依次比较相邻两个数据，大的数据向后交换。每一趟比较结束都会确定一个最大值。后面重复第一步骤
```


static void sort(int[] n){
//1.冒泡排序最多比较n.length-1
//2.每一趟比较i次(i初始值等于n.length-1)
for(int i=n.length-1;i>0;i--){//趟数
for(int j=0;j<i;j++){//次数
if(n[j]>n[j+1]){
int temp=n[j];
n[j]=n[j+1];
n[j+1]=temp;
}
}
System.out.println(Arrays.toString(n));
}
}
```


**2.简单选择排序**




算法：
依次比较相邻两个元素，找到最小值的下标位置。交换最小元素与初始下标位置的元素
```


public static int[] maoPao(int [] arr){
for(int i=0;i<arr.length;i++){
for(int j=i;j<arr.length;j++){
int temp=0;
if(arr[j]<arr[i]){
temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
return arr;
}
```


**多维数组(掌握二维)**




**多维数组变量的定义**
```


int[] a;
int[][] b;
int[][][] c;
```






**多维数组变量的赋值**




1.静态初始化
```


int[][]a ={}; length=0
int[][]b ={{}};length=1;
int[][]c={{1,2,3,4},{1}}
int[][][]d={{}};
int[][][]e={{1},{2}}
int[][]m;
m={{1}};//错的(静态初始化只能用在定义时)
```


2.动态初始化
```


int[][]n1=new int[4][3];
int[][]n2=new int[4][];
int[][]n3=new int[][3];错的
int[2][1]n4=new int[2][1];错误
n2[0]=1;错误
n2[0]=new int[2];
n2[1]=new int[3];
n2[4]=new int[3];错
int [][]n5=new int[][]{};
int [][]n5=new int[][]{{1,2},{2}};
int [][]n5=new int[2][]{{1,2},{2}};错误
```






3.多维数组元素的访问及长度




例如：
```


int [][]n5=new int[][]{{1,2},{3}};
n5.length=2;
n5[0].length=2;
n5[1].length=1;
n5[1][0]可以访问到3
```






#####案例 九宫格算法




九宫格填数(奇数阶)
1)第一个数填在第0行的正中间
2)下个数填写在上一个数的右上角
 a)行越界，数据在本列的最底端
 b)列越界，数据写到本行的最左边
 c)行列都越界,数据填写在上个数的下面
 d)位置被占用数据填写在上个数的下面
```
public class ArrayDemo06 {
public static void main(String[] args) {
   int n=3;
//定义一个奇数阶数组
int array[][]=new int[n][n];
//向数组中填写数据(如下循环中的i就是要填写的数)
//确定第一个数的位置
int row=0;//行号
int col=n/2;//列号
for(int i=1;i<=n*n;i++){
array[row][col]=i;
//计算下一个数的位置(右上角)
row--;
col++;
//如上位置有可能越界或被占用
//所以要考虑如下几种情况
//1.判定行越界,列不越界
if(row<0&&col<n){
row=n-1;
}
//2.判定列越界,行不越界
else if(row>=0&&col==n){
col=0;
}
//3.判定行列都越界
else if(row<0&&col==n){
row+=2;
col--;
}
//4.位置被占用了
else if(array[row][col]!=0){
row+=2;
col--;
}
}
//输出
   for(int i=0;i<array.length;i++){
    for(int j=0;j<array[i].length;j++){
    System.out.print(array[i][j]+"\t");
    }
    System.out.println();
   }
}
}
```