java的八种基本数据类型(java的三大特征)

java的八种基本数据类型

java的八大根本数据类型分别是：1、整型的byte、short、int、long；2、字符型的char；3、浮点型的float、double；4、布尔型的boolean。
（引荐教程：java入门教程）
自从Java发布以来，根本数据类型便是Java语言的一部分，分别是byte,short,int,long,char,float,double,boolean.
其间：
整型：byte,short,int,long
字符型：char
浮点型：float,double
布尔型：boolean
一.整型
Java中整型数据归于有符号数，即第一个bit位为0表明正整数，第一个bit位为1表明负整数。在计算机中负数由补码进行表明，那么补码怎么计算呢？
（视频教程引荐：java视频教程）
补码=源码取反+1；
如：
22，在计算机中的表明为00010110，
-22，取反：11101001，加1：11101010
byte
byte归于Java中的整型，长度为1字节8bit，取值10000000（-128）到01111111（127），变量初始化默认值为0，包装类Byte
short
short归于Java中的整型，长度为2字节16bit，取值1000000000000000（-32768）到0111111111111111（32767），变量初始化默认值为0，包装类Short
int
int归于Java中的整型，长度为4字节32bit，取值-2^31（-2,147,483,648）到2^31-1（2,147,483,647），变量初始化默认值为0，包装类Integer
long
long归于Java中的整型，长度为8字节64bit，取值-2^63（-9,223,372,036,854,775,808?）到2^63-1（9,223,372,036,854,775,8087），变量初始化默认值为0或0L，包装类Long
二.浮点型
Java中浮点型数据无法由二进制直接表明，而是一种对于实数的近似数据表明法，它遵从IEEE754标准
float
float归于Java中的浮点型，也叫单精度浮点型，长度为4字节32bit，变量初始化默认值0.0f，包装类Float
1.float结构
包含三部分：符号位、指数位、尾数位
符号位(S)指数位(E)尾数位(M)
长度1bit8bit23bit
阐明0表明正数，1表明负数格局为，E值规模：（0,255），指数位取值：（，方式为1.M或0.M。其间当E=0时，取1.M，称为正规方式，当E！=0时，取0.M，称为非正规方式
2.float取值
正规方式：
非正规方式：
根据上面公式很简单计算出float的取值规模为：
（最小值，当符号位S取1，指数位E取255)
(最大值，当符号位S取0，指数位E取255)
能取到其间的近似数据。
留意：根据指数位和尾数位的取值不同，还有许多特殊情况，如NAN，正无量，负无量，但平时根本不会用到，这儿不再深化；一起由于是近似值，因而无法表明金额，表明金额主张运用BigDecimal
double
double归于Java中的浮点型，也叫双精度浮点型，长度为8字节64bit，变量初始化默认值0.0d，包装类Double
1.double结构
包含三部分：符号位、指数位、尾数位
符号位(S)指数位(E)尾数位(M)
长度1bit11bit52bit
阐明0表明正数，1表明负数格局为，E值规模：（0,2047），指数位取值：（，)方式为1.M或0.M。其间当E=0时，取1.M，称为正规方式，当E！=0时，取0.M，称为非正规方式
2.double取值
正规方式：
非正规方式：
根据上面公式很简单计算出double的取值规模为：
（最小值，当符号位S取1，指数位E取2047)
(最大值，当符号位S取0，指数位E取2047)
能取到其间的近似数据。
留意：根据指数位和尾数位的取值不同，还有许多特殊情况，如NAN，正无量，负无量，但平时根本不会用到，这儿不再深化；一起由于是近似值，因而无法表明金额，表明金额主张运用BigDecimal
三.字符型
char
char归于java中的字符型，占2字节16bit，可以赋值单字符以及整型数值,变量初始化无默认值，包装类Character。
如：
chara=’a’;
chara=’中’;
chara=12;//取值规模0~65536，因为char类型在ASCII字符编码中，有对应的数值，可直接做运算，输出字符表中对应的字符
四.布尔型
boolean
在JVM中并没有供给boolean专用的字节码指令，而boolean类型数据在经过编译后在JVM中会经过int类型来表明，此刻boolean数据4字节32位，而boolean数组将会被编码成Java虚拟机的byte数组，此刻每个boolean数据1字节占8bit.
–Java虚拟机标准

java的三大特征

面向目标三大特性：封装、承继、多态。

封装:

将类的某些信息躲藏在类内部，不允许外部程序直接拜访，而是通过该类供给的办法来完结对躲藏信息的操作和拜访。
承继:

子类拥有父类的所有特色和办法（除了private润饰的特色不能拥有）,从而完结了完结代码的复用；
多态:

运用父类引证接受,不同的子类的目标实例,父类引证调用相同的办法,依据子类不同的实例,发生不同的成果1、封装

1）什么是封装
概念：尽可能躲藏目标的内部完结细节，控制目标的修正及拜访的权限。

拜访润饰符：private（可将特色润饰为私有，仅本类可见）

2）公共拜访办法
以拜访办法的方式，从而完结赋值与取值操作。

问题：依旧没有解决到不合法数据录入！

供给公共拜访办法，以保证数据的正常录入。
命名标准：
赋值：setXXX()//运用办法参数完结赋值
取值：getXXX()//运用办法回来值完结取值
3）示例

publicstaticvoidmain(String[]args){

inta;

Numnum=newNum();

//传入值100

num.setNum(100);

System.out.println(num.getNum());

}

privateinta;

//在调用get办法时，回来本类a的值

publicintgetNum(){

returna;

}

//接受传入的值100，并赋值给本类的a

publicvoidsetNum(intnum){

this.a=num;

}

4）过滤有用数据
在公共的拜访办法内部，增加逻辑判别，从而过滤掉不合法数据，以保证数据安全。

5）总结
get/set办法是外界拜访目标私有特色的唯一通道，办法内部可对数据进行检测和过滤。

2、承继

1）程序中的承继
程序中的承继，是类与类之间特征和行为的一种赠与或取得。
两个类之间的承继联系，必须满意“isa”的联系。
2）父类的挑选
现实生活中，很多类别之间都存在着承继联系，都满意“isa”的联系。

狗是一种动物、狗是一种生物、狗是一种物质。

多个类别都可作为“狗”的父类，需求从中挑选出最适合的父类。

功用越精密，重合点越多，越接近直接父类。

功用越粗略，重合点越少，越接近Object类。（万物皆目标的概念）

3）承继
语法：class子类extends父类{}//界说子类时，显现承继父类

publicclass子类名extends父类名{

//代码块

}

运用：发生承继联系之后，子类可以运用父类中的特色和办法，也可界说子类独有的特色和办法。

优点：既提高代码的复用性，又提高代码的可扩展性。

4）承继的特色
Java为单承继，一个类只能有一个直接父类，但可以多级承继，特色和办法逐级叠加。

5）不行承继
结构办法：类中的结构办法，只担任创建本类目标，不行承继。

private润饰的特色和办法：拜访润饰符的一种，仅本类可见。

父子类不在同一个package中时，default润饰的特色和办法：拜访润饰符的一种，仅同包可见。

3、办法重写

1）办法的重写/掩盖
办法重写准则：

办法称号、参数列表与父类相同。
回来值类型必须与父类相同或其子类
拜访润饰符可与父类相同或是比父类更广泛。
办法重写的履行：

子类重写父类办法后，调用时优先履行子类重写后的办法。

办法重写的特性：

子类重写父类办法时子类办法会掩盖父类办法。

子类重写父类办法，拜访等级不能严于父类办法。

子类重写办法名和类型与父类一样。

父类的结构办法无法重写，只能被掩盖。

示例:

//父类

publicclassAnimal{

//父类中吃的办法会输出“玩玩玩”

publicvoidplay(){

System.out.println(“玩玩玩”);

}

//父类中睡的办法会输出“睡睡睡”

publicvoidsleep(){

System.out.println(“睡睡睡”);

}

}

/**

*狗类承继父类

*/

publicclassDogextendsAnimal{

//进行办法重写，将办法重写输出为“狗玩飞碟”

publicvoidplay(){

System.out.println(“狗玩飞碟”);

}

}

publicclassTest{

publicstaticvoidmain(String[]args){

//实例化宠物目标

Dogd=newDog();

d.play();

d.sleep();

}

}

运转输出:

在这里刺进图片描绘

2）办法重写与办法重载的区别
相同点:办法名相同
不同点:
重载:参数列表不同,回来值与拜访润饰符无关
重写:参数列表相同,回来值相同或其子类,拜访润饰符不能比父类更严

4、super关键字

1）super关键字
super关键字可在子类中拜访父类的办法。

运用”super.”的方式拜访父类的办法，从而完结在子类中的复用；
再叠加额定的功用代码，组成新的功用。
2）super调用父类无参结构
super()：表明调用父类无参结构办法。假如没有显现书写，隐式存在于子类结构办法的首行。

3）super调用父类有参结构
super()：表明调用父类无参结构办法。

super(实参)：表明调用父类有参结构办法。
参结构被履行

4）this与super
this或super运用在结构办法中时，都要求在首行。
当子类结构中运用了this()或this(实参)，即不行再一起书写super()或super(实参)，会由this()指向结构办法完结super()调用。

classA{

publicA(){

System.out.println((“A-无参结构”));

}

publicA(intvalue){

System.out.println((“A-有参结构”));

}

}

classBextendsA{

publicB(){

super();

System.out.println(“B-无参结构”);

}

publicB(intvalue){

//super();这两货不能跟一起存在

this();

System.out.println((“B-有参结构”));

}

}

5、多态

概念：父类引证指向子类目标，从而发生多种形态。

二者具有直接或间接的承继联系时，父类引证可指向子类目标，即构成多态。

父类引证仅可调用父类所声明的特色和办法，不行调用子类独有的特色和办法。

1）多态的运用
办法重载可以解决接收不同目标参数的问题，但其缺点也比较显着。

首要，随着子类的增加，Master类需求持续供给大量的办法重载，多次修正并重新编译源文件。
其次，每一个feed办法与某一种详细类型构成了密不行分的联系，耦合太高。
场景一：运用父类作为办法形参完结多态，使办法参数的类型更为广泛。

publicclassAnimal{

//父类中吃的办法会输出“玩玩玩”

publicvoidplay(){

System.out.println(“玩玩玩”);

}

//父类中睡的办法会输出“睡睡睡”

publicvoidsleep(){

System.out.println(“睡睡睡”);

}

}

/**

*狗类承继父类

*

*

*

*/

publicclassDogextendsAnimal{

//狗类特有的办法“狗吃狗粮”

publicvoideat(){

System.out.println(“狗吃狗粮”);

}

}

publicclassTest{

publicstaticvoidmain(String[]args){

//实例化宠物目标

Animald=newDog();

d.play();

d.sleep();

//Themethodeat()isundefinedforthetypeAnimal

//关于类型动物，eat()办法未界说

//当咱们去调用子类目标的特有办法时，就会爆出上面的过错提示

//假如想要完结子类特有办法，就必须要强转

//d.eat();

((Dog)d).eat();

}

}

运转输出:

在这里刺进图片描绘

场景二：运用父类作为办法回来值完结多态，使办法可以回来不同子类目标。

示例:

//动物类父类

publicclassAnimal{

publicvoidfood(){

System.out.println(“…”);

}

}

//用extends关键字,承继父类特色

publicclassDogextendsAnimal{

publicvoidfood(){

System.out.println(“狗吃狗粮”);

}

publicvoidruning(){

System.out.println(“一向跑跑跳跳”);

}

}

//用extends关键字,承继父类特色

publicclassFishextendsAnimal{

publicvoidfood(){

System.out.println(“大鱼吃小鱼,小鱼吃虾米”);

}

publicvoidswimming(){

System.out.println(“小鱼儿,一向游”);

}

}

publicclassMaster{

//传入你的动物，并去给它喂养

publicvoidfood(Animalanimal){

System.out.println(“喂养”);

animal.food();

}

}

importjava.util.Scanner;

publicclassShopping{

//你没有动物，所以animal为空

Animalanimal=null;

//判别你要购买的宠物，并回来宠物类（狗、鱼）

publicAnimalshopping(inta){

if(a==1){

animal=newDog();

}elseif(a==2){

animal=newFish();

}

//this.animal=animal;

returnanimal;

}

publicvoidshowMenu(){

Scannerinput=newScanner(System.in);

System.out.println(“欢迎来到一只宠物宠物店”);

System.out.println(“请挑选喜欢的宠物:”);

System.out.println(“1.狗2.鱼”);

inta=input.nextInt();

Animalanimal=shopping(a);

Mastermm=newMaster();

mm.food(animal);

//用instanceof判别你买的是狗仍是鱼。

//狗就履行狗的特色和办法，鱼就履行鱼的特色和办法

if(animalinstanceofDog){

Dogd=(Dog)animal;

d.runing();

}elseif(animalinstanceofFish){

Fishf=(Fish)animal;

f.swimming();

}

}

}

//测验类

publicclasstext{

publicstaticvoidmain(String[]args){

Shoppingshop=newShopping();

shop.showMenu();

}

}

运转成果:

在这里刺进图片描绘

2）多态的静态和动态完结
动态绑定：即为重写/掩盖，办法的重写

动态绑定也叫后期绑定，在运转时，虚拟机依据详细目标实例的类型进行绑定，或许说是只要目标在虚拟机中运转创建了之后，才能确定办法属于哪一个目标实例的

依据实际目标是什么，就去找相应目标办法去履行。
动态绑定是在运转时才会履行（例如重写的办法）。
静态绑定：即为重载，办法的重载

一个办法的参数在编译阶段常被静态地绑定,它是依据参数列表的不同来区分不同的函数，通过修改之后会变成两个不同的函数

依据类型找相应的特色或许静态变量。
静态绑定是在编译时履行（如成员变量，静态办法）。