java学习笔记day2-基本数据类型、变量类型、 修饰符

float与double区别

资料：https://blog.csdn.net/yyqhwr/article/details/79712564

float a=1.3报错，可以写成float a=1.3f或float a=(float)1.3

基本数据类型

低  ------------------------------------>  高

byte,short,char—> int —> long—> float —> double

代码练习1：

public class PrimitiveTypeTest {
    public PrimitiveTypeTest(){
        
    }
    public static void main(String[] args){
        System.out.println(3*0.1);
        System.out.println(3*0.1==0.3);
        float a =1.3332221511111f;
        double b=1.333222151234111222345;
        float c=(float)1.3222222;
        float d=1.2f*2;
        double e=3*0.1;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
        System.out.println(e);
    }
}

结果1：

0.30000000000000004
false
1.3332222
1.3332221512341111
1.3222222
2.4
0.30000000000000004

 练习2：

public class PrimitiveTypeTest {
    public PrimitiveTypeTest(){
        
    }
    public static void main(String[] args){
//byte
        System.out.println(Byte.SIZE);
        System.out.println(Byte.MIN_VALUE);
        System.out.println(Byte.MAX_VALUE);
//int
        System.out.println(Integer.SIZE);
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);
        System.out.println();
//    float
        System.out.println(Float.SIZE);
        System.out.println(Float.MIN_VALUE);
        System.out.println(Float.MAX_VALUE);
    }
}

结果2：

8
-128
127
32
-2147483648
2147483647

32
1.4E-45
3.4028235E38

 练习3

import java.io.*;
public class ZiDongLeiZhuan {
    public static void main(String[] args){
//    1、自动类型转换    
        char c1='a';//定义一个char类型
        int i1=c1;
        System.out.println(i1);
        char c2='A';
        int i2=c2+1;
        System.out.println("char类型和int类型计算后的值："+i2);
        System.out.println("-----------分割线-----------");
//        2、强制转换，条件是转换的数据类型必须是兼容的。
        int i3=123;
        byte b=(byte)i3;
        System.out.println("int强制类型转换为byte类型后的值为："+b);
    }

}
结果：
97
char类型和int类型计算后的值：66
-----------分割线-----------
int强制类型转换为byte类型后的值为：123

变量类型

局部变量：方法、构造方法和语句块内，必须初始化；

实例变量：类中，方法、构造方法和语句块外，无static修饰；

类变量：类中，方法、构造方法和语句块外，static修饰；

局部变量练习1：

public class Variable {
    //1、变量类型
    /*int a,b,c;//声明三个int型整数：a、b、c
    int d=3,e=4,f=5;//声明3个整数并赋予初始值
    byte g=22;//声明并初始化g
    String h="runoob";//声明并初始化字符串
*/    

    /*static int allClicks=0;//类变量
    String str="hello world";//实例变量
    public void method(){
        int in=0;//局部变量，没有默认值，必须经过初始化
    }
    public Variable(){
        //构造方法中有局部变量
    }
*/
    //2、age 是局部变量，定义在pupAge（）方法中，它的作用域限制在这个方法中。
    public void pupAge(){
        //int age;//没有初始化时报错
        int age=0;
        age=age+7;
        System.out.println("小狗的年龄是："+age);
    }
    public static void main(String[] args){
        Variable var=new Variable();
        var.pupAge();
    }
}
结果：
小狗的年龄是：7

实例变量练习1：

public class Employ {
    //这个实例变量对子类可见
    public String name;
    //私有变量，仅在该类可见
    private double salary;
    //构造器中对name赋值
    public Employ(String empName){
        name=empName;
    }
    public void setSalary(double empSal){
        salary=empSal;
    }
    public void printEmp(){
        System.out.println("名字："+name);
        System.out.println("薪水："+salary);
    }
    public static void main(String[] args){
        Employ empOne=new Employ("RUNOOB");
        empOne.setSalary(1000);
        empOne.printEmp();
    }
}
结果：
名字：RUNOOB
薪水：1000.0

 类变量

    //如果其他类想要访问该变量，可以这样访问：Employ.DEPARTMENT
    private static double salary;
    public static final String DEPARTMENT="开发人员";
    public static void main(String[] args){
        salary=10000;
        System.out.println(DEPARTMENT+"平均工资"+salary);
    }

 修饰符

访问修饰符

public:公共

protected：可以被子类继承

private：不能被继承

练习：

    //私有访问修饰符private
public class Employ {
        private String format;
//    getFormat()方法防护format的值
    public String getFormat(){
        return this.format;
    }
//    setFormat(String)设置format的值
    public void setFormat(String format){
        this.format=format;
    }    
}

package com.runoob.test;
//protected子类重写父类的openSpeaker（）方法，该方法子类可见
class AudioPlayer {
    protected boolean openSpeaker(Speaker sp){
//        实现细节
    }

}
class StreamingAudioPlayer extends AudioPlayer{
    protected boolean openSpeaker(Speaker sp){
//        实现细节        
    }
}

 非访问修饰符

 static：

　　静态变量

　　静态方法

 final：

　　final 变量：“最后的、最终的”，变量一旦被赋值，不能重新赋值被 final 修饰的实例变量必须显式指定初始值。

　　final 方法：父类中final方法可以被子类继承，但是不能被重写

　　　　　目的就是防止该方法的内容被修改

　　final 类：不能被继承，没有类能够继承 final 类的任何特性。　　

abstract:

　　抽象类：唯一目的就是将来用于扩充。类中有抽象方法，类声明为抽象类。

　　抽象方法：抽象方法是一种没有任何实现的方法，该方法在子类中实现。任何继承类的子类必须实现父类的所有抽象方法，除非子类也是抽象类。

 

public class InstanceCounter {
//    static 修饰类变量和类方法,用来声明独立于对象的静态变量，无论一个类实例化多少个对象，它的静态变量只有一份拷贝。局部变量不能被声明为static变量
    private static int numInstances=0;
    protected static int getCount(){
        return numInstances;
    }
    private static void addInstance (){
        numInstances++;
    }
    InstanceCounter(){
    InstanceCounter.addInstance();
    }
    
    public static void main(String[] args){
        System.out.println("Starting with "+InstanceCounter.getCount()+" instances");
        for (int i=0;i<500;++i){
            new InstanceCounter();
        }
        System.out.println("Created "+InstanceCounter.getCount()+" Instances");
    }
}

运算符

    public static void main(String[] args){
//        算数运算符
        int a=10;
        int b=20;
        System.out.println("a+b="+(a+b));
        System.out.println("b++="+(b++));
        System.out.println("++b="+(++b));
        System.out.println("++a="+(++a));
        
    }