Day6：Java的类学习6.10常量变量类型转换学习总结

62 阅读 0 评论 41 点赞

我是靠谱客的博主落后麦片，最近开发中收集的这篇文章主要介绍Day6：Java的类学习6.10常量变量类型转换学习总结，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

总目标：学会JAVA
本周目标：Java的入门知识（6.5——6.12）
今日目标：(6月10日)

Java基础语法学习（3）
Java最常用的变成元素：常量与变量
Java变量常量作用域
Java类型转换

常量和变量声明方法
变量的命名规则
表达式中数据类型转化的技巧
变量的作用范围
常量和变量的作用技巧

常量

常量就是固定不变的量，一旦被定义，它的值就不能再被改变。
常量（Constant）：初始化（initialize）后不能再改变值！，不会变动值。

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

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

public class Demo09 {    
	public static void mian(String[] args){//快捷键：psvm
    static final double PI = 3.14;//final 代表常量
    final static double P =3.14;//final 修饰符，不存在先后顺序
    public static void main(String[] args) {//psvm
        System.out.println(PI);//3.14
        System.out.println(P);//3.14
    }
}

常量声明

常用语法为final 数据类型常量名称[=值]
常量名称通常使用大写的字母。例如 PI 、YEAR等。

常量应用

当常量用于一个类的成员变量时，必须给常量赋值，否则会出现编译错误。

public class TestFinal1{//TestFinal命名驼峰原则
		static final int YEAR = 365;
		public static void main(String[] args){
		System.out.println("两年等于"+2*YEAR+"天");
		}
}

输出：两年等于730天

常量（Constant）：初始化（initialize）后不能再改变值！，不会变动值。
所谓的常量可以理解成一种的特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
```
final 常量名 = 值 ;
final double PI= 3.14;
```

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

public class Demo09 {
    //psvm

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

变量

变量是利用声明方式，将内存中的某个块（block）留下来以供程序使用，可以声明为块记载的数据类型为整型、字符型、浮点型或是其他的数据类型，以作为变量保存之用。

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

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

   type varNamr [=value] [{,varName[=value]}];
//数据类型 变量名  =值；可以使用逗号隔开来声明多个同类型变量。

注意事项

每个变量都有类型，类型可以是基本类型，也可以是引用类型（String字符串）。
变量名必须是合法的标识符。

变量声明是一条完整的语句，因此每日一个声明都必须以英文分号结束。

public class Demo07 {
    public static void main(String[] args){
        //定义int a,b,c;
        int a=1,b=2,c=3;//程序可读性，不建议用。
        String name = "HelloWorld";
        char x = 'X';
        double p1 = 3.14;
    }
}

变量声明

/**
@Description 下面的程序声明了两个变量，一个是整型，另一个是字符型
*/
public class TestJavaIntChar
{
	public static void mian(String[] args){
	int num = 3;                     //声明一个整型变量num,赋值为3；
	char ch = 'z';                  //声明一个字符变量ch,赋值为z
	System.out.println(num+"是整数！");//输出num的值
	System.out.println(ch+"是字符！");//输出ch的值
	}
}

运行结果
3是整数！
z是字符！

变量的命名规则

变量也是一种标识符，所以它也遵循标识符的命名规则。
所有变量、方法、类名：英文见名知意
类成员变量：首字母小写和驼峰原则(除第一个单词以外，后面首字母大写)：monthSalary
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man，GoodMam
方法名：首字母小写和驼峰原则：run(), runRun()

变量作用域

public class Variable{
	Static int allClicks = 0;//类变量
	String str ="hello world";//实例变量
	public void method(){
		int i = 0;//局部变量
	}

}

成员变量
在类体中定义的成员变量，作用范围是整个类。
- 类变量
- 实例变量
局部变量

public class Demo08 {
    //类变量  static
    static double salary =2500;
    //属性：变量

    //属性变量：从属于对象：如果不自行初始化，这个类型的默认值 int:0 float,double:0.0  char:u0000
    //布尔值：默认为false
    //除了基本类型，其余的都是null
    String name;
    int age;
    char M;
    //main 方法
    public static void main(String[] args){//局部变量{有效期开始
        //局部变量：必须声明和初始化值
        int i = 10;
        System.out.println(i);//10

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

        //类变量 static
        System.out.println(salary);//2500.0

    }//局部变量}有效期结束

    //其他方法
    public void add(){

    }
}

类型转换

由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。

低——————————————————高

byte→short,char→int→long→float→duoble

低到高是容量，字节大小。浮点型float(小数)优先级大于整数long

运算中，不同类型的数据先化为同一类，然后再统一运算。

强制类型转换

public class Demo05 {
    public static void main(String[] args){
        int i =128;
        byte b = (byte) i;//内存溢出

        //强制转换  （类型）变量名  高——低
        //自动转换转换  低——高

        System.out.println(i);//128
        System.out.println(b);//-128
    }

}

自动类型转换

public class Demo05 {
    public static void main(String[] args){
        int i =128;
        double b =  i;

        //自动转换   低——高

        System.out.println(i);//128
        System.out.println(b);//128.0

        /*
        注意点：
        1.不能对布尔值进行转换
        2.不能把对象类型转换为不相干的类型
        3.把高容量转换到低容量的时候，强制转换
        4.转换的时候可能存在内存溢出，或者精度问题
         */
    }

}

注意点：

不能对布尔值进行转换
不能把对象类型转换为不相干的类型
把高容量转换到低容量的时候，强制转换

   System.out.println("====================");
  System.out.println((int)27.3);//23
  System.out.println((int)-45.89f);//-45
  //溢出
  System.out.println("====================");
  char c = 'a';
  int d = c+1;
  System.out.println(d);//98
  System.out.println((char) d);//b

转换的时候可能存在内存溢出，或者精度问题

public class Demo06 {
public static void main(String[] args){
  //操作比较大的数，注意溢出问题
  //JDK7新特性，数字之间可以用下划线分割
  int money = 1_000_000_000;//数值1thousand Million
  System.out.println(money);
  int years = 20;
  int total =money*years;
  System.out.println(total);//输出-1474836480 ，计算时溢出了
    long total2 = money*years;
    System.out.println(total2);//输出-1474836480 ，计算时溢出了
    //money*years默认是int ，转换之前已经存在
    long total3 = money*((long)years);
    System.out.println(total3);//输出20_000_000_000

    //数字后面加L 大写L
    long abc = 1_000_000_000_000L;
}
}

学习总结

今天学习的是Java最常用的编程元素——常量与变量。使用时要注意常量final和变量的声明与应用、变量的命名规则以及作用范围。在数据类型的转换中要注意常量、变量的赋值和运算优先级和占用内存大小，注意因溢出而导致的计算错误。

变量是利用声明的方式，将内存中的某个block保留下来以供程序使用。
常量就是固定不变的量，一旦被定义，它的值就不再被改变。
当常量用于一个类的成员变量时，必须给常量赋值，否则会出现编译错误。
变量的的命名规则
1、任意顺序的大小写字母、数字、“_”、“$”
2、不能用数字开头
3、不能用关键字
按作用范围，变量可分为：全局变量和局部变量
编写一个定义全局变量和局部变量的程序

//编写一个定义全局变量和局部变量的程序
public class LocalVarible {
  static final int SUM =10;//定义全局变量

   public static void main(String[] args) {
       int sum = 0;//定义局部变量sum
       for (int i=1;i<=SUM;i++)
       {
           sum=sum+i;
           System.out.println("i="+i+",sum="+sum);
           System.out.println(sum==SUM );
       }

   }

}

输出的结果为:

i=1,sum=1
false
i=2,sum=3
false
i=3,sum=6
false
i=4,sum=10
true
i=5,sum=15
false
i=6,sum=21
false
i=7,sum=28
false
i=8,sum=36
false
i=9,sum=45
false
i=10,sum=55
false