------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------
Java基础语法
一：学习java注意的地方
（1）Java在拼写上是严格区分大小写的
（2）一个Java源文件里可以定义多个Java类，但其中最多只能有一个类被定义成public类，并且该类名必须与文件名一样
（3）若源文件中包括了public类，源文件必须和该public类同名；
（4）一个源文件中包含多个Java类时，编译后会生成多个字节码文件，即每个类都会生成一份单独的.class文件，且字节码文件名和其对应的类名相同；
二：Java的语法格式
任何一种语言（自然语言或计算机语言）都有自己的语法规则,Java语言作为计算机语言的一种也是一样,这就要求必须按照其规则来书写
首先代码都是定义在类中,类由class来定义，区分 public class 和 class;代码也是严格区分大小写,如main和Main是不一样的;
Java中的标识符与关键字;
注释
1：单行注释//
2：多行注释/* */
3：文档注释/*/，这是java特有的注释方法(用于生成文档);
命名
包名所有字母小写 xxxyyyzzz
类名接口名，第一个字母大写 XxxYyyZzz
变量名和函数名，第一个字母不能大写 xxxYyyZzz
main方法的作用：
1：程序的入口
2：保证程序的独立运行
3：被JVM调用
三：Java中的标识符
可简单理解为在Java程序中为了增强阅读性自定义的名称。比如：类名，方法名，变量名等。
命名规则：
(1) 由字母、数字、下划线、$组成，不能以数字开头
注意:此处的字母还可以是中文,日文等;
(2) 区分大小写
(3) 不得使用java中的关键字和保留字
关键字：其实就是某种语言赋予了特殊含义的单词。
(4) 别用Java API里面的类名作为自己的类名。
四：java中的常量和变量
变量的概念：
（1）占据着内存中的某一个存储区域;
（2）该区域有自己的名称（变量名）和类型（数据类型）;
（3）该区域的数据可以在同一类型范围内不断变化;
为什么要定义变量：
用来不断的存放同一类型的常量，并可以重复使用；
使用变量注意：
变量的作用范围,初始化值
定义变量的格式：
数据类型变量名 =初始化值；
注：格式是固定的，记住格式，以不变应万变。
作用范围：定义开始到定义它的代码块结束;
同一范围内，不允许多个个局部变量命名冲突
五：Java成员变量和局部变量
局部变量：不是声明在类体括号里面的变量；
局部变量使用前必须初始化值;
局部变量没有默认初始化值;
局部变量的作用域是从定义开始到定义它的代码块结束;
成员变量:在方法体外,类体内声明的变量，又称字段(Field)或全局变量；
六、基本数据类型
数值型（Byte short int long）
浮点型（float占4个8位，double占8个8位）
字符型（char）
布尔型（boolean）这都是基本数据类型
字节是最小单位，是由8个二进制组成。
基本数据类型转换
向上转换：系统可以自动转型，
整型，字符型，浮点型的数据在混合运算中相互转换，转换时遵循以下原则：
容量小的类型可自动转换为容量大的数据类型；
容量小的类型可自动转换为容量大的数据类型；
byte,short,char → int → long → float → double
byte，short，char之间不会相互转换，他们在计算时首先会转换为int类型。
向下转换：需要强制类型转换。
package pract;
public class Show {
public static void main(String[] args) {
// 类型转换
byte a = 1 + 1; // 赋值操作，java系统会自动判断1+1是否在byte范围内，是java就自动做了自动类型转换。
byte b = 1; b = (byte)(b + 1);//因为b是byte型，b+1把b自动提升到int型，所以在进行赋值时需要强转。
byte c = 1; c = c += 1; // 这个表达式做了一次赋值运算，在赋值的同时，完成了自动转换动作。
byte d= 1; d = ++d; //b在进行自增后，做自动类型转换
System.out.println(a+"--"+b+"--"+c+"--"+d);
}
}
七Java的运算符
运算符是一种特殊符号，用以表示数据的运算、赋值和比较等共分以下几种：
算术运算符（+、-、*、/、%）
赋值运算符（=、+=、-=、*=、/=,、%=）
关系运算符（>、>=、<、<=、!=）
条件运算符（&&、||、！&、|、^）
位运算符（&、|、^、~、>>、<<、<<<、>>>）
八 switch控制语句
-
、当判断固定个数的值的时候，可以使用if，也可以使用switch。建议使用switch，效率相对较高。
switch(变量){变量类型必须为byte，short，int，char四种类型。
case值:要执行的语句;break;
…
default:要执行的语句; break;
}
结束switch语句的两种情况：遇到break，执行switch语句结束。
特例：如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。
注意：default可以写在switch结构中的任意位置；如果将default语句放在了第一行，则不管expression与case中的value是否匹配，程序会从default开始执行直到第一个break出现。
package pract;
public class SwitchTest{
public static void main(String[] args) {
//需求2：根据用于指定月份，打印该月份所属的季节。
//3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季
int x = 4;
switch(x){
case 3://当x为3,4,5其中一个时，遇到case相对应的
case 4://数，就不在判断case语句，向下执行，直到遇
case 5://到break结束。
System.out.println(x+"春季");
break;
case 6:
case 7:
case 8:
System.out.println(x+"夏季");
break;
case 9:
case 10:
case 11:
System.out.println(x+"秋季");
break;
case 12:
case 1:
case 2:
System.out.println(x+"冬季");
break;
default:
System.out.println("nono");
}
}
}
九三大循环结构:
用于处理需要重复执行的操作；
根据判断条件的成立与否，决定程序段落的执行次数，而这个程序段落我们称为循环体；
while:事先不需要知道循环执行多少次；
do while:同上，只是至少要执行一次(先做，后判断)；
for:需要知道循环次数；
循环结构(while & do while)
while语句
格式：
while(条件表达式值为true)
{
执行语句；
}
do while语句
格式：
do
{
执行语句；
}
while(条件表达式值为true);
我的总结：do while特点是无论条件是否满足，循环体至少被执行一次。
循环里的条件表达式不能直接写false或直接写结果是false的表达式,不过可以使用变量来传递false值;
循环结构(for)
格式：
for(初始化表达式（1）；循环条件表达式（2）；循环后的操作表达式（3）)
{
执行语句；（4）
}
执行顺序：(1) → (2) → (4) → (3) → (2) → (4) → (3)
备注：
1, for里面的3个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。
2, while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。
3, 最简单无限循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。
package pract;
public class XunHuan {
public static void main(String[] args) {
doWhile();
whileDemo();
forDemo();
}
public static void doWhile(){
int a = 0;
do{
System.out.println("a"+a);
a--;
}while(a>0);
}
public static void whileDemo(){
int b = 1;
while(b<2){
System.out.println("b"+b);
b++;
}
}
public static void forDemo(){
for(int c=0;c<1;c++){
System.out.println("c"+c);
}
}
}
十嵌套循环与流程控制
嵌套循环：循环里套循环
假设外循环的循环次数是m次,内循环的循环次数是n次，那么内层循环的循环次数需要m * n次。
练习 制作九九乘法表；用/t
package pract;
public class XunHuan {
public static void main(String[] args) {
forDemo();
}
public static void forDemo(){
for (int x=1; x<=9 ; x++){
for (int y=1; y<=x; y++){
System.out.print(y+"*"+x+"="+y*x+"\t");//不换行
}
System.out.println();//打印完换行
}
}
}
十一流程控制
break语句、 continue语句；
break：终止该层循环；
continue：跳过该层循环
注：
①：若这两个语句离开应用范围，存在是没有意义的。
②：这个两个语句后面都不能有语句，因为执行不到。
③：continue语句是跳过本次循环，继续下次循环。
④：标签的出现，可以让这两个语句作用于指定的循环。
package pract;
public class XunHuan {
public static void main(String[] args) {
forDemo();
}
public static void forDemo(){
for (int x=1; x<=9 ; x++){
for (int y=1; y<=x; y++){
if(x>3)//当满足x>3的时候，结束循环
break;
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
}
一：数组的概念
数组实质上就是同一种数据类型的数据的一个集合，是一个容器，是引用类型，存储在堆空间中。
好处:可以自动给数组中的元素从0开始编号，方便对这些元素进行操作
格式1. int[] arr=new int[5];创建一个长度为5，数组名为arr,类型为整型的数组。
引用时格式：arr[下标]
格式2. int[] arr=new []{5,6,8,3,4}
int[] arr={5,6,8,3,4}
每一个数组中都有一个属性length，用于记录数组的长度
数组中常见异常问题：
1、数组下标越界 //ArrayIndexOutofBoundsException
2、空指针异常 //NullPointerException当引用没有任何指向值为空的情况时，该引用还在用于操作实体。
数组的操作：
1.获取数组中的数据，通常会用到遍历（for循环），arr.length代表数组的长度
package pract;
public class ArrayDemo {
public static void main(String[] args) {
int[] arr = {4,4,1,2,9,3};
System.out.println(getMin(arr));
}
public static int getMin(int[] arr){
int min = arr[0];//首先假设角标0的元素是最小值
for(int x=1; x<arr.length; x++){//遍历数组
if(arr[x]<arr[min])//通过判断数组中值得大小获取最小值
min = x;
}
return arr[min];//返回最小值
}
}
//数组排序
package pract;
public class ArrayDemo {
public static void main(String[] args) {
int[] arr = {4,4,1,2,9,3};
selectSort(arr);
printArray(arr);
}
public static void selectSort(int[] arr)//条件排序
{
for (int x=0; x<arr.length-1 ; x++){
for(int y=x+1; y<arr.length; y++){
if(arr[x]>arr[y]){
swap(arr,x,y);
}
}
}
}
// 冒泡排序
public static void bubbleSort(int[] arr)
{
for(int x=0; x<arr.length-1; x++){
for(int y=0; y<arr.length-x-1; y++){//-x:让每一次比较的元素减少，-1：避免角标越界。
if(arr[y]<arr[y+1]){
swap(arr,y,y+1);
}
}
}
}
public static void swap(int[] arr,int a,int b){//数组元素交换位置
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
public static void printArray(int[] arr){//打印数组
System.out.print("[");
for(int x=0; x<arr.length; x++){
if(x!=arr.length-1)
System.out.print(arr[x]+", ");
else
System.out.println(arr[x]+"]");
}
}
}
折半查找
package pract;
public class ArrayDemo {
public static void main(String[] args) {
int[] arr = {1,2,4,9,10,11};
int num =halfSearch(arr,9);
System.out.println(num);
}
/*
折半查找。提高效率，但是必须要保证该数组是有序的数组。
*/
public static int halfSearch(int[] arr,int key){
int min = 0,max = arr.length-1,mid;
//角标 ：最小值，最大值 ，中间值
while(min<=max){//只要min<max
mid = (max+min)>>1;//(max+min)/2
if(key>arr[mid])
min = mid + 1;//改变最小角标
else if(key<arr[mid])
max = mid - 1;
else
return mid;
}
return -1;//找不到则返回-1
}
}
二维数组:数组中的数组
int[][] arr=new int [3][4];//定义了一个名称为arr的二维数组，这个二维数组中有3个一位数组，每一个一位数组中有四个元素，
//3代表的是二维数组的长度，4代表的是二维数组中每一个一位数组的长度。
arr.length:二维数组的长度
arr[0].length:二维数组中第一个一位数组的长度
二维数组的遍历
package pract;
public class ArrayDemo {
public static void main(String[] args) {
int[][] arr = {{1,2,3},{4,5,6}};
for(int x=0;x<arr.length;x++){
for(int y=0;y<arr[x].length;y++){
System.out.println(arr[x][y]);//遍历数组中的元素
}
}
}
}
821
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
