java基础

Java基础语言主成：
Java语言开发的规范：
1.1关键字

1.2标识符
由英文字母大小写组成，数字：0-9符号：-$
定义法则：1，数字不可以开头
2，关键字不能作为标识符
1.3注释
表示：//单行注释
/*
*/：多行注释
注释包含的方面
重点内容：
1.需求
2.思路：
3步骤

思路  ：
1，定义一个类，因为Java程序都定义在类中，Java程序都是以类的形式存在的，类的形式其实就是一个字节码文件的最终的体现
2，定义一个主函数。为了能够让该类进行独立运行
3，演示hello world，在控制台上看到字样，故需要使用输出语句运行。
代码仅仅是思想的一种体现。
步骤：
用class关键字来进行类的定义，取个类名
用主函数：public static void main(String[] agrs);固定格式。jvm认识
因需要将其hello world输出到控制台上，故需要使用输出语句完成。
class Dmeo{
    //定义一个主函数
    public static void main(String[] args){
        //输出语句，用括号将其打印其控制台上，
        System.out.println("hello World");
    }
}

1.4常量与变量
常量的类型：
1.4.1：
整数常量，
小数常量，
布尔值常量（boolean）{只有true，false}，
字符常量
字符串常量，
null常量（只有一个值：null）
变量：
1内存中的一个区域，
2该区域有自己的名称（变量名）和类型（数据型
3该区域的数据可以在同一类型范围内不断变化
为什么定义变量：
用来存放同一类型的常量，并可以重复使用；
格式：
*重点内容：
数据类型 变量名 = 初始值；*

数据类型 ：基本数据类型和引用数据类型
基本数据类型：
1.1数值型：整数（byte，short，int，long），浮点（float，double），
字符（char），布尔（boolean）；
1.2引用类型：类（class），接口（interface），数组（[]）
整数默认，int，小数默认：double
数据类型的自动转换：

1.5运算符
算术运算符，（+ -,*,/）
赋值运算符，
比较运算符，(==,!=,<,>,<=,>=,instanceof(检查是否是类的对象))；

逻辑运算符（&，|，^,!,&&,||）

&:(false&true)=false;
|:(false|true)=true;
^:(false^false);
!:(not(非)){！true}=false;
/*&与&&(短路)的区别：
结果是一样的，但运算过程有点区别
 &：无论左边的运算结果是什么，右边都参与运算；
 &&：当左边为false，右边不参与运算。
比如：
x=1;
x>2&x<5:false;(需要同时运算)；

x>2&&x<5:false;(运算一边就可以了既可以得出)；
&&:false&&true = false;
||:OR:(false||true) =true;
|与||的区别：跟&和&&的区别是一样的；

位（二进制运算）运算，
<<(左移)

右移

无符号右移
&与运算（6&3=2）
|或运算（6|3=7）
^异或运算
~反码（基本不做运算）

异或运算：一个数异或同一个数两次，结果还是这个数。

最有效的运算方式（位运算）：算出2*8的整数
：交换两个数的数值（不用第三方变量值）；

class {
    public static void main(String[] agrs){
        //最有效率的方式算出2*8 = 16
        System.out.println("2<<3");
        //计算两个数的互换值
        int a=3,b=5;
        //对两个整数变量的值进行变换(不需要第三方量)
        /*
        int c ;
        c = a;
        a = b;
        b = c;
        */
        //不能用，两整数数值过大，会超出范围
        a = a + b;
        b = a - b;
        a = a - b;
        //位运算(最快)面试时用
        a = a ^ b;
        b = a ^ b;
        a = a ^ b;
    }
}

三元运算符
（条件表达式）？表达式1：表达式2；
如果条件为true，运算为表达式一，否则为表达式2；

1.6语句
判断语句，选择结构，循环结构

/*
    if语句的第一种格式；
    1，
    if(条件表达式)
    {
        执行语句；
    }
*/
int x = 3;
if(true){
System.out.println("yes");
}
/*
if(条件表达式)
{
    执行语句    ;
}
else if(条件表达式)
{
    执行语句;
}
else if(条件表达式)
{
    执行语句;
}
else
{
    执行语句;
}
*/
//
class IfTest{
    public static void main(String agrs[]){

    }
}
//提示用户输入一个整数，如果该数字是5的整数倍，打印HiFive。如该
//数字能被2整除，打印HiEven。
switch语句：
格式：
switch(表达式)
{
case：取值1：
    执行语句;
    break;
case：取值2：
    执行语句;
    break;

case：取值3：
    执行语句;
    break;

....
default:
    执行语句;
    break;
}
    System.out.println("Hello World");

if与switch的区别：优缺点,应用场景。
if：
  1//对具体的值进行判断。
  2，//对区间判断。
  3,//对运算结果是boolean类型的表达式进行判断。
switch:
  1//对具体的值进行判断。
  2//值得个数通常是固定的
  //对于几个固定的值判断，建议使用switch语句，因为switch语句会将
  //具体的答案都加载进内存。

1.6.3
循环结构：while，do while ,for.
while 语句格式：
while（条件表达式）{
执行语句；
}
do while 语句格式：
do{
执行语句；
}while(条件表达式)；
do while 特点：
是条件无论如何是否满足，
循环体至少执行一次。

class WhileTest{
    public static void main(String[] args)
    {
    /*
    练习1到10的练习
    思路：
    每次参与的运算的数值不确定。
    每次出现的和数据也不确定；
    每次参与的加法运算的值有递增规律；
    每次都是加法运算在重复，并且都是和加下一个数值。
     *
    /
    do{
        int i = 1;
        int sum = 0;
        sum = sum +i;
        i++;
        }while(i<=10)

    }
}
    int x = 1;
    int sum = 0;
    while(x < = 10)
    {
        sum = sum + i;
        i++;
    }
    /*
    思路：
        首先设置一个变量来统计6的倍数的出现的次数；
        遍历1-100范围，用判断语句来判断6的倍数的整数，并记录其个数；
        int x = 1;
        int count = 0;
        while(x < = 100)
        {
            if (x % 6 ==0)
                count ++;
                System.out.println("x = :"+ x);
                x++
        }
        System.out.println("count ="+ count);

    */
    循环结构：
    格式：
    for(初始表达式；循环表达式；循环后的操作表达式)
    {
        执行循环语句；
    }
    for 与 while 的特点：
    1，for 和 while 可以互换；
    2，格式上的不同，在使用上有点小区别；
        如果需要通过变量来对循环进行控制，
//while(true){};无限循环最简单的表达式；
//什么时候使用循环结构，
//当对某些代码执行很多次时，使用循环结构完成；
//当对一个条件进行一次判断时，可以使用if语句；
//当对一个条件进行多次判断时，也可以使用while语句；
注意：
    在使用循环时，一定要明确哪些语句需要参与循环，那些不需要；
    循环通常需要控制条件，需要控制其范围；
    for (int x = 0; x< = 4;x++)
    {
        for(int y = 0; y < = 5;y++)
        {
            System.out.println("*");
        }
        System.out.println();

    }
    /*
        九九乘法表：
        1*1 = 1；
        1*2 = 2； 2*2 = 4；
        for(int x = 1; x<= 9;x++)
        {
            for(int y = 1; y < = x; y++)
            {
                System.out.println(y + "x" + x +"="+y*x + "");

            }
            System.out.println();
        }

    */
    /*
    \n:回车符：
    \t:制表符：
    \b:表格：
    \r:按下回车键。
    windows系统中回车符其实是由两个字符的\r\n;
    linux中回车符是 \n.
    */
    //打印
    * * * * *
     * * * *
      * * *
       * *
        *
        for(int x = 1; x < =5 ; x ++)
        {
            for(int y = 1 ;y < x ; y ++)
            {
                System.out.print("-");
            }
            for( int z = x ; z < = 5;z++)
            {
                 System.out.print("*");   
            }
            System.out.println();
        }   

break(跳出)，continue（继续）
brreak语句：应用范围：选择结构和循环结构。
continue语句：应用于循环结构。
注意：
a，这两个语句离开应用范围，存在是没有意义的
b，这两个语句单独存在下面都不可以有语句，因为执行不到。
c,continue语句是结束本次循环继续下次循环。
d，标号的出现，可以让这两个语句作用于指定范围

/*
    break:跳出。
    break作用的范围：要么是switch语句，要么是循环语句。
    记住:当break语句单独存在时，下面的不要定义其他语句，因为执行不到；
    break跳出当前循环。
    如果出现了的循环嵌套，break想要跳出指定的循环，可以通过标号来完成；
    for( int x = 0; x <3;x++)
    {
        for(int y = 0;y < 4; y++)
        {
            System.out.println("x="+x);
            break;
        }
    }
    /*
        continue：继续。
        作用的范围：循环结构。
        continue：结束本次循环，继续下次循环。
        如果continue单独存在时，下面不要有任何语句，因为执行不到；
    */
    for(int x = 0; x < = 11;x ++)
    {
        if(x%2==0)
            continue;
        System.out.println("x="+x);
    }
    xiaoqiang:for(int  x = 0;x <3;x++)
    {
        wangcai:for(int y = 0; y<4;y++)
        {
            System.out.println("x="+x);
            continue xiaoqiang;

        }
    }
*/

1.7函数
函数的概念：
1.函数就是定义在类中的具有特定功能的独立小程序；
2函数也称为方法。
函数格式的格式：
//函数名字必须要可读性；
修饰符 返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2，…）
{
执行语句；
return 返回值；
}
//特殊情况：
功能没有具体的返回值。
这时return的后面直接用分号结束。
返回值类型怎么体现呢，因为没有具体值，所以不可以写具体的数据类型
在java中只能用一个股关键字来表示这种情况，关键是：void。
总结：没有具体返回值时，返回类型用void来表示。
注意：如果返回值类型void，那么函数中的return省略不写。
函数的特点：
定义函数可以将功能代码进行封装
便于对该功能进行复用
函数只有被调用时才会被执行
函数提高了代码的复用性
对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写
注意：
函数只能调用函数，不可以在函数内部定义函数。
定义函数时，函数的结果应该返回给调用者，交由调用者处理。
public static int add（int a,int b）{
return a + b；
}

//定义一个功能，完成两个整数的和的获取。
思路：既然定义功能，就是可以用函数来实现。
如何定义一个函数
通过两个明确来完成。
明确一：这个函数的结果是什么？
是和。功能的结果，所以该功能的返回值类型是int。
明确二：这个函数的功能实现是否需要未知内容参与运算
有，加数和被加数，这就是函数的参数列表（参数的个数，参数的类型）
public static int add(int a,int b){
    int sum = a+b;
    return sum;
}
//需求1：定义一个功能，画一个矩形在控制台；
/*
    思路：明确一：这个函数的结果是什么？
        没有结果，因为直接打印到了，控制台，并未返回给调用者。
        用void表示；
        明确二：这个函数的功能实现是否需要未知内容参与运算
        有，行和列不确定。两个。整数 int
        public static void draw()
        {
            for(int x = 1; x < row ;x++ )
            {
                for(int y = 1;y < col;y++){
                    System.out.print("*");
                }
                System.out.println();
            }
            return;
        } 
    需求3：定义一个功能，比较两个数的是否相等。
    思路：有结，只是比较两数大小，用boolean值，并返回给调用者；
         这函数实现其功能需要未知两个数的进行比较运算；并返回结果。

    public static blooean  equals(double a,double b){
            if(a == b){
                return true;
            }else
            {
                return false;
            }

    }

*/

// 函数的重载；
重载的概念
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可
重载的特点：
与返回值类型无关，只看参数列表。
重载的好处：
方便于阅读，优化了程序设计。
//返回两个整数的和
int add（int x,int y）{return x+y};
//返回三个数的最小和
int add(int x,int y,int z){return x+y+z};

1.8数组
//数组的定义
概念：同一个类型数据的集合。其实就是一个容器。
数组的好处
//可以自动给数组中的元素从0开始编号，方便操作这些元素。
格式1:
元素类型[] 数组名 = new 元素类型[元素个数或数组的长度]；
示例：int [] arr = new int [5]；
格式2：
元素类型[] 数组名 = new 元素类型[]{元素，元素，元素……};
int [] arr = new int []{3,5,1,7};
int [] arr = {3,4,5,7};
/*
内存的划分：
1.寄存器。
2本地方法区
3方法区
4栈内存
//存储的都是局部变量
而且变量所属的作用域一旦结束，该变量就自动释放。
5堆内存
存储的是数组和对象（其实数组都是对象）凡是new，建立在堆中。
特点：1,每一个实体都有首地址值。
2，堆内存中的每一个变量都有默认初始化值，根据类型的不同而不同。整数是0，小数0.0或者0.0f
3，垃圾回收机制。

*/

“`
class ArrayDemo2
{
public static void main(String[] agrs)
{
//格式1
/*
需要一个容器，但是不明确容器的具体数据。

    */
    int [] arr = new int[3];

// arr = null;
System.out.println(arr);

    //当引用型变量没有任何实体指向时，还在用其操作实体，就会发生异常；
    /*
    需要一个容器，存储已经的具体数据。
     */
     //无论那门语言，遇到容器重点学；
    //int [] arr = new int[]{89,34,470,17};
    /*
    对数组操作最基本的动作就是存取；
    核心思想：就是对角标的操作；
    */

}

}
//数组的常见的操作；
//获取数组中的最大值。
思路：
1，需要进行比较。并定义变量及记录每次比较后的最大值。
2，对数组中元素进行遍历取出，和变量中记录的数值进行比较。
3，遍历结果，该变量记录就是最大值。
//当其数组中的数值为负数时，故有问题。
public static int getMax(int [] arr){
int max = 0;
for(int x = 0;x