Java学习（二）数据类型、变量、类型转换

一、数据类型

1、基本数据类型

1. 整数型

1.  byte 字节型

内存空间 = 1字节 = 8个bit

共有256种组合

数值范围：

-2的7次方~2的7次方-1 ==》-128~127

2. short 短整型

内存空间 = 2字节 = 16个bit

共有65526种组合

数值范围：

-32768~32767

3.  int 整型

内存空间 = 4字节 = 32个bit

数值范围：

-2147483648~2147483647

4.  long 长整型

内存空间 = 8字节 = 64个bit 代码内容 数值范围：

-2的63次方~2的63次方-1

定义时，如果取值超过int类型的取值范围，程序编译检测的时候会认为数字太大，如果我们真的需要那么大的数字，需要在后面加上L表示long，告诉电脑并没有错误

如：long a=2147483648L;

注意：大小写的L都可以，建议大写

2. 浮点型

float 单精度

4字节 = 32个 bit

定义时，需要需要在后面加上F表示float，告诉电脑并没有错误

如：float a=3.4F;

注意：大小写的f都可以，建议大写

double 双精度

8字节 = 64个 bit

3. 字符型

chat

加上单引号都是为字符

2字节 = 16bit

4. 布尔型

boolean

true/false

1bit

2、引用数据类型

1. 数组[]

数组本身是一个引用类型，数组内存储的类型可以是基本类型也可以是引用类型

数组的定义（声明）

//创建数组的写法：
int[] x;
char[] y;
boolean[] z;
String[] m;

//注意：下面的写法也好使，但是不规范
int x[];
int []x;

数组的赋值（初始化）

• 静态初始化

• 特点：有长度，有元素

  int[] arr = new int[]{10,20,30,40,50}
  //数组定义时，后面的new int[]可以省略
  int[] arr = {10,20,30,40,50}
  //赋值时后面的new int[]必须写
  int[] arr；
  arr = new int[]{10,20,30,40,50}

• 动态初始化

  特点：有长度，没有元素（不是真的没有元素，只是有默认值）

  //后面的方括号内为初始化数组的长度
  int[] arr = new int[5]
  //各类型初始化的默认值：
  // 整数 => 0
  // 浮点 => 0.0
  // 字符 => 0对应的字符（ASCII码）
  // 布尔 => false
  // 引用 => null

2. 类class（抽象类abstract class）

类的命名规范：

需要遵循大驼峰式的写法，即每个单词首字母都大写

创建类的方式：

public class Person {
   //***定义类的属性-->静态描述类的特征（变量 存值）
   /*
   权限修饰符（必须） 数据类型 属性名字
    */
   //名字
   public String name;
   //年齡
   public int age;
   //性別
   public String sex;

   //***定义类的方法-->动态描述类的行为
   /*
   权限修饰符（必须） 返回值类型 方法名字
    */
   //无参数无返回值  如果没有返回值的话，参数类型使用void
   public void sleep() {
       System.out.println("我在睡觉");
   }
   //无参数有返回值  返回名字的类型为string
   public String showMyName() {
       return this.name;
   }
   //有参数无返回值  参数需要在小括号内定义
   public void eat(String sonmething) {
       System.out.println("我在吃"   sonmething);
   }

   //***定义类的构造方法-->用来创建当前类的对象
   /*
   构造方法没有返回值的结构，但是是有返回值的，返回值为对象
   每个类都有构造方法，若是自己未定义，系统则会默认提供一个无参数的构造方法，若是在类中自己定义了构造方法，则默认无参数的构造方法即被覆盖
   权限修饰符 类名一致的方法名 (参数)[可有可无的异常]
    */
   public Person(){};
   //重载一个可以传参的，直接修改属性
   public Person(String name,int age,String sex) {
       this.name = name;
       this.age = age;
       this.sex = sex;
       System.out.println("我叫" this.name "，我" this.age "岁了，我的性别是" this.sex);
   }

   //***程序块（代码块）-->理解为就是一个方法（非常特殊的，无修饰符无参数无返回值无名字的方法）
   /*
   因为啥都没有，所以写法就是一个大括号
   可以在类中定义多个程序块
   代码块不是我们自己调用的，它是我们每一次调用构造方法之前，系统会自动帮我们调用一次程序块，让它执行一遍
    */
   {
       System.out.println("我是一个普通的程序块");
   }
}

使用类创建对象：

public static void main(String[] args) {
   //新建一个对象
   Person test = new Person();

   //修改对象的属性
   test.name = "tachmiao";
   test.age = 16;
   test.sex = "男";
   System.out.println("我叫" test.name "，我" test.age "岁了，我的性别是" test.sex);

   //执行对象内的方法
   test.sleep();
   System.out.println(test.showMyName());
   test.eat("大米饭");

   //调用构造方法创建一个对象
   Person testFun = new Person("贪吃喵",18,"男");
}

运行结果：

我是一个普通的程序块

我叫tachmiao，我16岁了，我的性别是男

我在睡觉

tachmiao

我在吃大米饭

我是一个普通的程序块

我叫贪吃喵，我18岁了，我的性别是男

关键字this

1. this可以调用属性、方法

2. this可以在一个构造方法中调用另一个重构的构造方法（必须放在第一行），通过this()来调用，省略了构造方法的名（必须和类名一致）

3. this可以在放置在类中的任何成员位置，上下顺序随意

3. 接口interface

接口也是一个类的结构，只不过是用interface修饰，替换原有的class

创建接口

public interface InterfaceTest{
   //属性
   //不能含有一般的属性，只能含有共有的静态的常量
   public static final String name = "tachmiao";
   //可以省略属性之前的修饰符，不过默认修饰符作用全部存在,可以写成如下：
   String name = "tachmiao";
   
   //方法
   //不能含有一般具体的方法，只能含有共有的抽象的方法
   public void test();//只定义规则，不描述具体过程
   //1.8版本之后可以用default来修饰
   default void test(){};
   
   //块
   //不能含有块（块本身就是具体的，接口不能拥有具体的）
   
   //构造方法
   //不能含有构造方法
}

如何使用

接口没有构造方法，所以不能直接创建对象，只能通过子类多实现（implements）来做事

接口与接口、接口与类之间的关系

接口不能继承其他的类；

接口可以直接多继承接口；

抽象类可以直接多实现接口 public abstract class A implements B,C{}；

具体类不可以直接多实现接口（需要将接口中的抽象方法具体化，否则该子类也需要变成抽象类）

4. 枚举enum

5. 注解@interface

二、常量/变量

命名规则：

• 字母(大小写敏感)

• 数字(0~9，不允许开头)

• 符号(英文符号_$)

• 中文

命名规范：

• class类名字（大驼峰写法）

• 变量名（小驼峰写法）

注意：

变量可以只创建控件，不存放东西，空的变量是无法拿来使用的

1、常量

常量的值不能改变

final int a = 1;

2、变量

声明变量时，必须指定数据类型，变量空间的名字

变量中的值可改变

声明变量：

//数据类型 变量名字
int a;
String b;

三、类型转换

基本数据类型

小数据类型一致

小数据类型指的是整数型，浮点型

//1.类型一致的或者容量小的赋值给容量大的，可以直接赋值
int a = 1;
int b = a;
byte x = 1;
int y = a;

//2.容量大的赋值给容量小的，需要强制类型转换
int a = 1;
//int内存空间为32bit，byte只有8bit，所以需要加上byte强制转换
//如果转换前的数额大于转换后的数据类型空间大小，强制转换之后结果会改变
byte b = (byte)a;
double x = 3.4;
float y = (float)x;

小数据类型不一致

整型—浮点型

比较两个类型的精确程度，浮点型精确程度更高，可以直接存放整数，反之需要强制转换

int a = 1;
float b = a;//==>1.0

float x = 1.9;
int y = (int)x;//==>1

整型—字符型

每个字符都对应一个Unicode码   如：a–97

char x = 'a';
int y = x;//==>97
//因为char内存空间小于int的内存空间，所以需要强制转换
int x = 97;
byte x = 97;//编译的时候，做值计算时也是转换成int，所以还是需要强制转换
char y = (char)x;//==>a

布尔型

不能与其他基本类型进行转换

引用类型与基本类型

将string类型的转换成基本类型，需要通过包装类实现

int 类型的包装类为 Integer

char 类型的包装类为 Character

其他的类型的包装类都是首字母大写的类型名

例：

//将String类型的123转换成int类型
String a = "123";
int b = Integer.parseInt(a);

将基本类型转换成String类型，最快的方法是在后面拼接一个空字符串

如：123 "" 得到的将会是一个"123"