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）多态的静态和动态完结
动态绑定：即为重写/掩盖，办法的重写
动态绑定也叫后期绑定，在运转时，虚拟机依据详细目标实例的类型进行绑定，或许说是只要目标在虚拟机中运转创建了之后，才能确定办法属于哪一个目标实例的
依据实际目标是什么，就去找相应目标办法去履行。
动态绑定是在运转时才会履行（例如重写的办法）。
静态绑定：即为重载，办法的重载
一个办法的参数在编译阶段常被静态地绑定,它是依据参数列表的不同来区分不同的函数，通过修改之后会变成两个不同的函数
依据类型找相应的特色或许静态变量。
静态绑定是在编译时履行（如成员变量，静态办法）。
