Java基础（二）

Java基础（二）

1、变量

• 变量是什么：就是可以变化的量！

变量就是指内存中的一块空间，但这个空间里放什么是不确定的。

例如：家里有个大大的衣柜

柜子
衣服
袜子
鞋子

这个柜子本身就存在（跟我们电脑的内存一样），只是我们给加了个标签而已来说明哪个格子放什么东西。

内存也一样，我们需要给指定一个空间放什么东西，某个数据类型（比如int整数），放了A、B、C、D四个都是整数，为了来区分就要给他们起名字（也就是变量名），东西（值）就随便放（在鞋子这一栏里无论放阿迪、耐克等等都可以）

• Java是一种强类型语言，每个变量都必须声明其类型。
• Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

type varName [=value] [{,varName[=value]}];
//数据类型 变量名 = 值; 可以使用逗号隔开来声明多个同类型变量。
//例如
int a=1,b=2,c=3;  //但尽量不要这样使用

不建议在一行中定义多个值

• 注意事项：
  • 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
  • 变量名必须是合法的标识符。
  • 变量声明是一条完整的语句，因此每一个声明都必须以分号结束。

代码

public class Demo07 {
    public static void main(String[] args) {
        //int a,b,c;
        //int a=1,b=2,c=3;  这两种都可以，但是不建议在一行中定义多个变量
        int a = 1;
        int b = 2;  //要注重程序的可读性

        String name = "小小树苗l";
        char x = 'X';
        double pi = 3.14;
    }
}

变量的作用域

• 类变量
  • 需要加一个关键词static
• 实例变量
  • 跟类变量差不多，但是没有static关键词
• 局部变量
  • 写在方法中的
    

类变量

类变量从属于Demo08这个类，会随着这个类一起出来，一起消失

类变量代码

public class Demo08 {

    //类变量 static
    //类变量从属于Demo08这个类，会随着这个类一起出来，一起消失
    static double salary = 2500;

    //main方法  主程序方法
    public static void main(String[] args) {

        //类变量 static
        System.out.println(salary);
    }
    //除了main方法还可以写其他方法
    //其他方法
    public void add(){

    }
}

输出结果

2500

实例变量

实例变量从属于对象

理解为从属于Demo08这个类，要通过这个类才可以使用它，而且很高级

* 实例变量可以不初始化，如果不进行初始化的话，会输出默认值
    * 所有的数值类型初始化：0  0.0
* 字符串变量的话初始化：u0000  也还是0
* 布尔值默认：false
* 除了基本类型，其他默认值都是null;

实例变量代码

public class Demo08 {
    //属性可以理解为变量

    //实例变量
    String name;
    int age;

    //main方法  主程序方法
    public static void main(String[] args) {
        //变量类型 变量名字 = new Demo08();
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.age);  //0
        System.out.println(demo08.name);  //null
    }
    //除了main方法还可以写其他方法
    //其他方法
    public void add(){

    }
}

上面是一个类demo08里面有两个，name跟age，后面那个想用到类里必须声明Demo08（名字）=new Demo08

输出结果

0
null

局部变量

局部变量必须声明和初始化

局部变量目前可以理解为就是在这两个大括号之间的，生命周期从‘’{‘’开始，到‘’}‘’就结束了

局部变量代码

public class Demo08 {
    //属性可以理解为变量

    //main方法  主程序方法
    public static void main(String[] args) {
        int i = 10;
        System.out.println(i);
    }
    //除了main方法还可以写其他方法
    //其他方法
    public void add(){

    }
}

输出结果

10

变量总代码

public class Demo08 {

    //类变量 static
    //类变量从属于Demo08这个类，会随着这个类一起出来，一起消失
    static double salary = 2500;

    //类中除了定义方法还可以定义一些属性
    //属性可以理解为变量

    //实例变量：从属于对象
    //理解为从属于Demo08这个类，要通过这个类才可以使用它，而且很高级
    /*
    * 实例变量如果不进行初始化的话，会输出默认值
    * 所有的数值类型初始化：0  0.0
    * 字符串变量的话初始化：u0000  也还是0
    * 布尔值默认：false
    * 除了基本类型，其他默认值都是null;
    * */
    String name;
    int age;

    //main方法  主程序方法
    public static void main(String[] args) {

        //变量类型 变量名字 = new Demo08();
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.age);  //0
        System.out.println(demo08.name);  //null

        //局部变量目前可以理解为就是在这两个大括号之间的，生命周期从{开始，到}就结束了
        //局部变量：必须声明和初始化值
        int i = 10;
        System.out.println(i);

        //类变量 static
        System.out.println(salary);
    }
    //除了main方法还可以写其他方法
    //其他方法
    public void add(){

    }
}

2、常量

• 常量(Constant)：初始化(initialize)后不能再改变值！不会变动的值。

• 所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

  final 常量名=值;
  final double PI=3.14;
  

• 常量名一般使用大写字符。

static final double PI = 3.14;

final static double PI = 3.14;

通过调换修饰符发现，修饰符不存在先后顺序

在代码中使用一些常量可以增加代码的可读性，把一些固定的值设置成常量。比如游戏里的一些数值，可以定义成静态的常量无论在什么位置都可以调用

常量代码

public class Demo09 {
   //修饰符，不存在先后顺序
   static final double PI = 3.14;
   public static void main(String[] args) {
       System.out.println(PI);
   }
}

变量的命名规范

• 所有变量、方法、类名：见名知意
• 类成员变量：首字母小写和驼峰原则：monthSalary
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线：MAX _VALUE
• 类名：首字母大写和驼峰原则：Man，GoodMan
• 方法名：首字母小写和驼峰原则：run(),runRun()

3、运算符

Java语言支持如下运算符：

• 算术运算符：+，-，*，/，%，++，--
• 赋值运算符：=
• 关系运算符：>，<，>=，<=，=，！=，instanceof
• 逻辑运算符：&&，‖，！
• 位运算符：&，|，^，~，>>，<<，>>>（了解！！！）
• 条件运算符： ？：
• 扩展赋值运算符：=，-=，*=，/=

二元运算符

package operator;

public class Demo01 {
    public static void main(String[] args) {
        //二元运算符

        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;

        System.out.println(a+b);  //30
        System.out.println(a-b);  //-10
        System.out.println(a*b);  //200
        System.out.println(a/b);  //0

        //取余，也叫模运算
        System.out.println(c%a);  // c / a = 25 /10 = 2...5
        
    }
}

输出结果

30
-10
200
0
5

发现个问题，为什么 System.out.println(a/b);的输出结果为0，不是0.5吗？

a和b都是int型的，除完之后还是int型的，就把小数点后的给舍掉了（这里不存在四舍五入，小数点后的直接删）

改成System.out.println(a/(double)b);后输出结果就为0.5了。

package operator;

public class Demo02 {
    public static void main(String[] args) {
        long a = 1121212121212L;
        int b = 123;
        short c = 10;
        byte d = 8;

        System.out.println(a+b+c+d);  //1121212121353  Long类型
        System.out.println(b+c+d);  //141  int类型
        System.out.println(c+d);  //18  int类型
    }
}

输出结果

1121212121353
141
18

多个操作数中，操作数最高为Long,那么运算结果类型也为Long，如果是byte，int，short，那么结果都为Int。如果最高有double，结果是double类型；

关系运算符

package operator;

public class Demo03 {
    public static void main(String[] args) {
        //关系运算符：返回结果 true/false  布尔型
        int a = 10;
        int b = 20;

        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);
    }
}

输出结果

false
true
false
true

一元运算符(自增、自减)

package operator;

public class Demo04 {
    public static void main(String[] args) {
        //++ -- 自增、自减  一元运算符
        int a = 3;
        int b = a++;  //执行完这段代码后，先给b赋值，再自增
        int c = ++a;  //执行完这段代码前，先自增，再给c赋值

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

        //幂运算 2^3=8   2*2*2 = 8
        //很多运算，我们会使用一些工具类来操作！
        double pow = Math.pow(2,3);
        System.out.println(pow);

    }
}

输出结果

5
3
5
8.0

分析

就是原来a=3，后来b是先赋值后自增，因为是先赋值的话，b是等于3。后来才加1，这个时候a已经加1了，等于4了。然后c是先自增后赋值，那就是4先加1咯，那就等于5呗，所以a=5，c也等于5

问a为什么等于5的 不管a 前加加 还是后加加 反正加了几次 a就等于几

逻辑运算符

package operator;
//逻辑运算符
public class Demo05 {
    public static void main(String[] args) {
    //与（and）    或(or)     非(取反)
        boolean a = false;
        boolean b = true;

        System.out.println("a && b:"+(a && b));  //逻辑与运算：两个变量都为真，结果才为真
        System.out.println("a || b:"+(a || b));  //逻辑或运算：两个变量有一个为真，结果就为真
        System.out.println("!(a && b):"+!(a && b));  //逻辑非运算：取反，如果为真，则变为假

        //短路运算
        //在System.out.println("a && b:"+(a && b));中  a为假则结果直接为假，不会对b进行判断，结果直接输出false
        int c = 5;
        boolean d = (c<4)&&(c++<4);
        System.out.println(d);  //false
        System.out.println(c);  //这里c还是5，所以没有进行c++运算，判断（c<4）不成立后就直接结束了
    }
}

逻辑运算

• 逻辑与运算（&&）

  • 两个变量都为真，结果才为真
  • 有一个变量为假，结果就为假

• 逻辑或运算（||）

  • 两个变量有一个为真，结果就为真
  • 两个变量都为假，结果才为假

• 逻辑非运算（！）

  • 如果为真，则变为假
  • 如果为假，则变为真

短路运算

在进行逻辑与（a&&b）运算时，如果a为假，则不会进一步验证b的真假（这一步不会被执行，直接输出false）

位运算符

package operator;
//位运算符
public class Demo06 {
    public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101
    --------------------------
      A&B = 0000 1100
      A|B = 0011 1101
      A^B = 0011 0001
       ~B = 1111 0010

        问：2*8怎么运算最快？
        2*8 = 16    2*2*2*2
        << : 左移    *2
        >> : 右移    /2
        效率极高！！！
        0000 0000    0
        0000 0001    1
        0000 0010    2
        0000 0011    3
        0000 0100    4
        0000 1000    8
        0001 0000    16
         */
        System.out.println(2<<3);
    }
}

位运算

• &都为1才为1

• |都为0才为0

• ^相同为0，否则为1

• <<和>>直接和底层相连的，运算效率极高，以后在算法的地方会经常使用。

• >>>是右移，且把高位补0

拓展赋值运算符

package operator;

public class Demo07 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 10;
        int d = 20;

        a+=b; //a=a+b
        System.out.println(a);
        c-=d; //c=c-d
        System.out.println(c);

        System.out.println("=====字符串连接符=====");
        //字符串连接符 + ,string 
        a = 10;
        b = 20;

        System.out.println(a+b);
        System.out.println(""+a+b); //1020  不进行运算，直接拼接
        System.out.println(a+b+""); //30  先运算，后拼接

    }
}

输出结果

30
-10
=====字符串连接符=====
30
1020
30

思考

为什么System.out.println(""+a+b)和System.out.println(a+b+"")不同？

+的运算顺序是自左到右

所以(""+a+b) 不进行运算，直接拼接，而(a+b+"") 先运算，后拼接。

三元运算符

package operator;
//三元运算符
public class Demo08 {
    public static void main(String[] args) {
        //x ? y : z
        //如果x==true,则结果y,否则结果为z

        int score = 50;
        String type=score<60?"不及格":"及格";  //必须掌握
        System.out.println(type);
    }
}

学好了 ？ 吃穿无忧 ：喝西北风

4、包机制

• 为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。

• 包语句的语法格式为：

  package pkg1[.pkg2[.pkg3...]];
  

• 一般利用公司域名倒置作为包名；

  com.baidu.www

  

• 为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用import语句可完成此功能

  import package1[.package2...].(classname|*);
  

5、JavaDoc

• javadoc命令是用来生成自己API文档的

• 参数信息

  @author作者名
  @version版本号
  @since指明需要最早使用的jdk版本
  @param参数名
  @return返回值情况
  @throws异常抛出情况

加在类的上面，就是类的注释

加在方法的上面，就是方法的注释

生成javadoc文档的方法

• 通过命令行

  • javadoc 参数 Java文件 javadoc -encoding UTF-8 -charset UTF-8 Doc.java

• 学会查找使用IDEA生产的avaDoc文档！ 面向百度编程！

  1. 在IDEA中选择工具（Tool）选项卡打开

  2. 选择生成JavaDoc

     

     • 第一步：选择生成JavaDoc文档的范围

       • 可选择整个项目
       • 某个文件
       • 或者自定义范围

     • 第二步：选择一个输出目录

     • 第三步：区域设置，决定文档的语言

       简体中文	繁体(台湾)	繁体(香港)	英语(香港)	英语(美国)	英语(英国)	英语(全球)
       zh_CN	zh_tw	zh-hk	en-hk	en-us	en-gb	en-ww

     • 第四步：参数一般为-encoding UTF-8 -charset UTF-8

     • 第五步：完成后点击确定

  3. 查看JavaDoc文档
     打开输出目录，打开 index.html 就能看生成的文档。

基础部分的一切知识，几乎以后每一天都要用