Java基础 7 类型转换 接口 内部类

标识符是什么？

标识符就是java语言编程中名字。

java命名规则

1，所有的标识符只能包含字母，数字 ，下划线（_），美元符号($);

2, 不能以数字开头

3，不用使用java的关键字作为标识符

4，Java中大小写敏感 A a

java命名规范 驼峰式命名

1，类名，接口名 每一个单词的首字母大写

2,方法名，变量名 第一个单词的首字母小写以后的每一个单词的首字母大写 personMessage stuNo stuName

3,常量 每一个字母均大写

关键字

java赋予这些单词有特殊的含义

保留字

现在java没有用到词但是它认为在以后的版本中会赋予特定的含义的词 const goto

变量（储存数据的容器）

在程序运行过程中会改变的量

现实生活中 农药 烧杯 = 敌敌畏; 果汁 水杯=橙汁;

java代码当中 int a = 10 ;

使用变量三步曲

1，申明变量（定义变量）

数据类型 变量名; 例：int a ;

2，为变量赋值

a=20 ;

3,使用变量（打印输出，运算）

System.out.println(a);

数据类型

基本数据类型（4类共8种）

整型：字节型（byte） 占一个字节（8位 8bit） -128 到 127

短整型（short）占两个字节（16位） -32768 到 32767

整型(int) 占4个字节（32位） -20多亿 到 20多亿

长整型(long) 占8个字节（64位）-2的64次方 到 （2的64次方-1）

浮点型：单精度浮点型float 占4个字节（3.4*10的38次方） 有效位数为8位

双精度浮点型double 占8个字节（1.79*10的308次方） 有效位数为16位

逻辑（布尔）型：boolean 占一个bit 只有两个值 true , false

字符型：char 占两个字节

引用数据类型 类,接口，数组

整型数据类型

注意：java语言当中默认的整数类型为int

如果需要表示long类型的数据，则需要在数据后面加上L或l

浮点型数据

java中的小数默认是double类型，如果需要表示float类型则需要在数据的后面加上F或f

字符型

char 类型的数据用''引起来，且''中有且仅有一个字

数据类型转换

自动类型转换

存储容量小的数据类型的数据可以直接转换成存储容量大的数据类型的数据

整数和整数之间的转换

byte-->short-->int-->long-->float-->double

字符和整数之间的转换

char-->int-->long-->float-->double

如：char c = 'c';

int i = c ;

System.out.println(i);

强制类型转换

存储容量大的数据类型转换成存储容量小的数据类型，不能直接转换

注意：强制类型转换可能会造成数据精度的损失，所以在你不确定这个数是否会大于某种数据类型的最大值时，不建议强制转换

如：long l1 = 100 ;

int i1 =(int) l1 ;

System.out.println(i1);

运算符

一种特殊的符号，用于表示数据的运算，赋值，比较等

运算符分类

算数运算符 + - * / ++ --等

赋值运算符 = += -= *= /=

比较运算符 > < == >= <=等

逻辑运算符 && || ！

三目运算符 表达式？表达式：表达式

/**

数据类型练习

*/

public class DataType

{

public static void main(String[] args)

{

/*在Java语言中默认的整数类型为int*/

//byte数据类型

byte b = 127;

System.out.println(b);

//short数据类型

short s = 32000;

System.out.println(s);

//int数据类型

int i = 33000;

System.out.println(i);

//long数据类型 在Java中如果需要表示long类型的数据则需要在数据的后面加上L或者l

long l = 123456789987654321l;

System.out.println(l);

//单精度浮点数据float

//java中的小数默认是double类型，如果需要表示float类型则需要在数据的后面加上F或f

float f = 3.141592654f;

System.out.println(f);

float f1 = 123456789f ;

System.out.println(f1);

//双精度浮点型double

double d = 3.141592654123456;

System.out.println(d);

//字符型数据 char

char c = '1';

System.out.println(c);

//逻辑型（布尔型）boolean

boolean b1 = true;

System.out.println(b1);

boolean b2 = false ;

System.out.println(b2);

}

}

/**

数据类型转换

自动类型转换

存储容量小的数据类型的数据可以直接转换成存储容量大的数据类型的数据

byte --> char -->short-->int-->long-->float-->double

如：char c = 'c';

int i = c ;

System.out.println(i);

强制类型转换

存储容量大的数据类型转换成存储容量小的数据类型，不能直接转换

注意：强制类型转换可能会造成数据精度的损失，所以在你不确定这个数是否会大于某种数据类型的最大值时，不建议强制转换

如：long l1 = 100 ;

int i1 =(int) l1 ;

System.out.println(i1);

*/

public class TypeConvert

{

public static void main(String[] args)

{

//自动类型转换

char c = '你';

int i = c ;

System.out.println(i);

long l = i ;

System.out.println(l);

float f = l ;

System.out.println(l);

double d = f ;

System.out.println(d);

//强制类型转换

long l1 = 10000000000l ;

int i1 =(int) l1 ;

System.out.println(i1);

double d1 = 3.141592654333;

float f1 = (float)d1 ;

System.out.println(f1);

}

}

/**

变量练习

变量使用三步曲

1，定义变量

2，给变量赋值

3，使用变量（打印或做运算）

*/

public class VarTest

{

public static void main(String[] args)

{

//定义变量

int a; //int 是数据类型 a是变量名

//给变量赋值

a = 10 ;

//使用变量

System.out.println(a+10);

//直接定义变量并赋初始值

int b = 10;

b = b+20 ;

System.out.println("b="+b);

/*

y = 20 ;

x = y+10 ;

问 x=?;

*/

//定义变量（申明变量）

int y ;

int x ;

//为变量赋值

y = 20 ;

x = y+10 ;

//使用变量（打印输出）

System.out.println("x="+x);

}

}

/**

算数运算符练习

+

-

*/

public class Test

{

public static void main(String[] args)

{

int a = 10 ;

int b = +a ;//这时候+的含义表示正数

System.out.println(b);

int c = -a ;//这时-的含义表示负数

System.out.println(-c);

System.out.println(c);

int d = a+b ;//这时+的含义是表示两个数相加

System.out.println(d);

d = a+c ;//d = 10 +(-10);

System.out.println(d);

d = a-c ;//

System.out.println(d);

}

}

public class lxzh

{

public static void main(String[] args)

{

byte a=10;

int b=a;

//这个位置发生了一个类型转换 自动类型转换 a从byte转换到int类型

// 这是相当于 吧一个小数据放入大容器中 所以没有问题

}

}

//强制类型转换 如:

double b=10.2;

int c=(int)b ;

// 括号在数据前面 加要的数据类型 上面这个例子 会将小数直接去掉

//强制转换会造成数据丢失

接口

接口可以理解为一个特殊的抽象类

接口只能定义两种内容

1，抽象方法

2，常量

定义接口的语法 需要用到关键字 interface

[修饰符] interface 接口名

{

常量

抽象方法

}

注意：在接口中，所有的变量默认有public static final 修饰

在接口中，所有的方法默认有public abstract 修饰

public interface MyInterface

{

double PI = 3.14 ; //常量

double area(); //抽象方法

double girth() ; //抽象方法

}

接口的使用方法

接口必须有类去实现

语法

[修饰符] class 类名 [extends 父类名] [implements 接口名1,接口名2....接口名n]

{

成员方法，成员变量，

必须实现所有接口，和父类中的抽象方法

}

注意：在Java中，类实现接口是多实现，就是一个类可以实现多个接口

接口与接口之间的继承是多继承的

语法

[修饰符] interface 接口名 [extends 父接口1,父接口2....]

{ }

注意:

1，接口只能继承接口

2，子接口一旦继承了父接口，那么该子接口将拥有父接口中所有的常量和方法

练习：

需求

定义三个接口，一个是动物AnimalInterface 一个狗 DogInterface 一个生物接口 ShengWuInterface

AnimalinterFace中有一个方法 sleep() //睡觉

DogInterfacle中有一个方法 look() //看家

生物接口 ShengWuInterface breath() //呼吸

定义一个土狗类 TuGou 要求实现 DogInterface接口，需要同时拥有DogInterface中的方法，和AnimalInterface中的方法和ShengWuInterface的方法

内部类：

定义在类中的类

内部类的分类

1，成员内部类

2，局部内部类

3，静态内部类

4，匿名内部类

成员内部类：

成员内部类和成员变量与成员方法是同级的

1，成员内部类可以直接访问外部类的成员变量和成员方法

2，如果成员内部类中的变量与外部类的变量发生重名时，使用外部类名.this.变量名访问外部类的成员变量

3，如果成员内部类中的方法名与外部类的方法名发生重名时，使用用外部类名.this.方法名([参数]) 访问外部类的成员方法

4，成员内部类的使用

在外部类中可以直接声明成员内部类的对象作为外部类的成员变量

也可以直接在外部类的成员方法中，直接声明成员内部类的对象作为方法的局部变量

5，在其他类中访问另一个类的成员内部类，并调用其方法？

1，创建外部类对象

2，声明并创建内部类对象

外部类名.内部类名 内部类的对象名 = 外部类的对象名.new 内部类名([参数]);

3,调用内部类的方法

内部类的对象名.内部类的方法名([参数]);

静态内部类：

1，只能访问外部类的静态成员

访问方式

访问外部静态成员变量 外部类名.变量名

访问外部静态成员方法

如果内部类中没有重名的方法则直接使用 外部类的方法名();

如果内部类中有重名的方法 外部类的类名.方法名()

2,只有静态内部类中的成员变量和成员方法可以用static修饰

3，外部类可以使用内部类名.变量名 访问静态内部类的静态变量

外部类可以使用内部类名.方法名([参数...]) 访问静态内部类的静态方法

4,在其他类中，访问另一个类的静态内部类，并调用实例方法？

1，声明变量

外部类名.内部类名 内部类的对象名;

2,创建对象

内部类的对象名 = new 外部类名.内部类名([参数...]) ;

3,调用方法

内部类的对象名.方法名([参数....]);

5,如何在其他类中，访问一个类的静态内部类的静态成员

外部类名.内部类名.静态成员变量名|静态成员方法名([参数]);