Java语言 day03

Java入门篇

变量

• 变量：就是可以变化的量；

• Java是一种强类型语言，每个变量都必须声明其类型；

• Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域；

 

 

 

【注：

1. 每个变量都有类型，类型可以是基本类型，也可以是引用类型。

2. 变量名必须是合法的标识符。

3. 变量声明是一条完整的语句，因此每一个声明都必须以分号(；)结束。

】

变量作用域

• 类变量

关键字：static。

• 实例变量

通过new来调用；

• 局部变量

变量只在被定义的某个程序块内或在方法体内部有效，这种类型的变量通常被称为局部变量。

程序块，就是使用“{”和“}”包含起来的代码块。

代码演示：

public class Virable {
    /*属性：变量
    * 变量如果不自行初始化，
    * 数值类型的默认值为0/ 0.0 u0000；
    * 布尔值：默认值为false；
    * 除了基本类型，其余的默认值都为null；
    * */
​
    //类变量 static
    static double salary = 5000;
​
    //实例变量
    String name;
    int age;
​
    //main方法
    public static void main(String[] args) {
        //局部变量;使用前必须声明和初始化值；
        int i = 21;
        System.out.println(i);
​
        //实例变量： 变量类型 变量名 = new 变量();
        Virable virable = new Virable();
        System.out.println(virable.age);
        System.out.println(virable.name);
​
        //类变量 关键词 static
        System.out.println("工资:"+salary);
    }
    //其他方法
    public void add(){
//      System.out.println(i); //局部i变量出了作用域没有用了。
​
    }
}
​

运行结果：

 

 

 

变量名的命名规范(***)

• 所有变量、方法、类名：见名知意！！！

• 类成员变量：首字母小写和驼峰原则：monthSalary 除第一个的单词以外，后面的单词首字母大写 lastName。

• 局部变量：首字母小写和驼峰原则。

• 常量：大写字母和下划线：MAX_VALUE。

• 类名：首字母大写和驼峰原则：Man，GoodMan。

• 方法名：首字母小写和驼峰原则：run()，runMan()。

 

---

---

常量

常量(Constant)，初始化后不能再改变值！不会变动的值。可以将常量理解为一种特殊的变量，它的值被设定后，再程序运行中不允许被改变。

 

 

 

【注：

常量名一般使用大写字符】

代码演示：

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

运行结果：

 

 

 

---

---

运算符

Java语言所支持的运算符：

 

 

 

算术运算演示代码：

package base;
​
public class Operator {
    public static void main(String[] args) {
        //二元运算符
        int a = 10;
        int b = 20;
        int c = 23;
        int d = 13;
​
        System.out.println(a+b);
        System.out.println(c-d);
        System.out.println(a*c);
        System.out.println((double) a/b); //除出来小数时要注意！！！
    }
}
​

运行结果：

 

 

 

扩展演示：(算数运算符下的类型转换)

package base;
​
public class Operator02 {
    /*使用运算符后的类型转换
    * 不同级别参加运算，类型自动转为最高级；
    * 没有Long或double等高于int级别的类型参加运算，自动转为int型；
    * 还可以进行强制转换；
    * */
    public static void main(String[] args) {
        Long l = 1231231234L;
        int i = 123;
        short s = 12;
        byte b = 8;
​
        System.out.println(l+i+s); //自动转为long型；
        System.out.println((s+b)); //int型;
        System.out.println((double) i+s); //强转为double型;
​
        //测试判断输出的类型
        Object h1 = l+i+s;
        Object h2 = (s+b);
        Object h3 = (double)i+b;
​
        if (h1.getClass().equals(Long.class)){
            System.out.println("h1为Long型");
        }else{
            System.out.println("h2不为Long型或出错！");
        }
​
        if (h2.getClass().equals(Integer.class)){
            System.out.println("h2为int型");
        }else{
            System.out.println("h2不为int型或出错！");
        }
​
        if (h3.getClass().equals(Double.class)){
            System.out.println("h3为double型");
        }else{
            System.out.println("h3不为double型或出错！");
        }
    }
}
​

运行结果：

 

 

 

关系运算符演示代码：

package base;
​
public class Operator03 {
    //关系运算符返回的结果：正确(true)，错误(false)  布尔值
    //与if一起使用
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 23;
​
        //取余
        System.out.println(c%a);
        //关系运算
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(c==b);
        System.out.println(a!=c);
    }
​
}
​

运行结果：

 

 

 

a++运算与++a运算的区别：

package base;
​
public class Operator04 {
    public static void main(String[] args) {
        // ++ --  自增，自减    一元运算；
        // ++a 与 a++ 的区别，相应的 a--与--a同样道理;
        int a = 6;
        int b = a++;  //执行完这行代码之后，先给b赋值，再自增；
        int c = ++a;  //执行完这行代码之后，先自增，再给b赋值；
​
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
​
        //幂运算，Java中许多运算，我们会使用一些工具类去操作！
        double pow = Math.pow(6,2);
        System.out.println(pow);
​
    }
}
​

运行结果：

 

 

 

逻辑运算演示代码：

package base;
​
//逻辑运算符
public class Operator05 {
    public static void main(String[] args) {
        //与(and)  或(or)  非(取反)
        boolean a = true;
        boolean b = false;
​
        System.out.println("a && b:"+(a&&b));      //逻辑与运算：两个变量都为真，结果才为true
        System.out.println("a || b:"+(a||b));      //逻辑或运算：一个变量为真，结果为true
        System.out.println("!(a && b):"+!(a&&b));  //逻辑与运算：变量为真，则变为假；变量为假，则变为真；
​
        //短路运算
        int c = 6;
        boolean d = (c<5)&&(c++<5);
//      boolean f = (c<5)||(c++>5);
        System.out.println(d);
        System.out.println(c); //c++并没有被执行；
    }
}
​

运行结果：

 

 

 

 

位运算演示代码：

package base;
​
//位运算
public class Operator06 {
    /*
    * A = 0011 1100
    * B = 0000 1101
    * ----------------
    * A&B = 0000 1100
    * A|B = 0011 1101
    * A^B = 0011 0001
    * ~B = 1111 0010
    * 位运算常用于算法，底层运算，效率极高！
    * <<  *2
    * >>  /2
    * */
    public static void main(String[] args) {
        System.out.println(2<<6);
    }
}
​

运行结果：

扩展运算符演示代码：

package base;
​
//扩展运算符
public class Operator07 {
    public static void main(String[] args) {
        int a = 10;
        int b = 21;
        a+=b; // a=a+b;
//      a-=b; // a=a-b;
        System.out.println(a);
​
        //字符串连接符 +  如果连接运算符(+)两边任意一个出现string类型，则默认将两边都当作字符串去连接；
        System.out.println(""+a+b);
        System.out.println(""+(a+b));  //如果要进行加减运算需将运算变量用()括起来。
​
    }
}
​

运行结果：

三元运算符演示代码：

package base;
​
//三元运算符
public class Operator08 {
    public static void main(String[] args) {
        // x ？ y ： z ；
        //如果 x==true，则结果为y,否则结果为z；
​
        int score = 95;
        String type = score < 60 ? "不及格":"及格"; //相当于if
        System.out.println(type);
    }
}
​

运行结果：