Java学习(二)数据类型、变量、类型转换

缪金谷 78 0

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"



目录导航
  • Java学习(二)数据类型、变量、类型转换
    • 一、数据类型
      • 1、基本数据类型
        • 1. 整数型
          • 1. byte 字节型
          • 2. short 短整型
          • 3. int 整型
          • 4. long 长整型
        • 2. 浮点型
          • float 单精度
          • double 双精度
        • 3. 字符型
          • chat
        • 4. 布尔型
          • boolean
      • 2、引用数据类型
        • 1. 数组[]
          • 数组的定义(声明)
          • 数组的赋值(初始化)
        • 2. 类class(抽象类abstract class)
            • 类的命名规范:
            • 创建类的方式:
            • 使用类创建对象:
            • 关键字this
        • 3. 接口interface
          • 创建接口
          • 如何使用
          • 接口与接口、接口与类之间的关系
        • 4. 枚举enum
        • 5. 注解@interface
    • 二、常量/变量
          • 命名规则:
          • 命名规范:
            • 注意:
      • 1、常量
      • 2、变量
    • 三、类型转换
      • 基本数据类型
        • 小数据类型一致
        • 小数据类型不一致
          • 整型---浮点型
          • 整型---字符型
          • 布尔型
      • 引用类型与基本类型
  • 发表评论 (已有0条评论)

    还木有评论哦,快来抢沙发吧~