day2面向对象

day2面向对象

java的4类8种数据类型

基本数据类型：（8位 == 1bit）

• 整数型：
  • byte：8位
  • short：16位
  • int：32位
  • long：64位（结尾可以加上L）
• 浮点型
  • float：32位（结尾可以加上F）
  • double：64位
• 字符型
  • char：16位
• 布尔型
  • boolean

public class Chap01 {
    public static void main(String[] args) {
        byte b1 = 2;
        short s1 = 3;
        int i1 = 4;
        long l1 = 5L;
        // java.lang.Integer, byte/short/int相互加减乘除，结果都是int类型
        System.out.println(getType(s1 + i1));
        // java.lang.Long,  有long参与的运算，结果为long型（向上转型）
        System.out.println(getType(b1 + l1));
        float f1 = 6F;
        // java.lang.Float, 同理
        System.out.println(getType(l1 + f1));
        double d1 = 7;
        // java.lang.Double
        System.out.println(getType(l1 + d1));
        char c1 = '丰';
        // java.lang.Integer: 20020     (使用字符对应的ACCII码进行计算)
        System.out.println(getType(c1 + i1) + ": " + (c1 + i1));
        System.out.println(Integer.valueOf(c1));    // 20016
        
        boolean bool = true;
    }

    public static String getType(Object o){
        return o.getClass().getTypeName();
    }
}

类型转换

public class Chap02 {
    public static void main(String[] args) {
        // 数据类型转换
        int i1 = 23;
        byte b1 = (byte) i1;
        // java.lang.Byte: 23
        System.out.println(Chap01.getType(b1) + ": " + b1);
        int i2 = i1; i2 = 129;
        byte b2 = (byte) i2;
        // java.lang.Byte: -127    存在内存溢出问题
        System.out.println(Chap01.getType(b2) + ": " + b2);
        // i1=23, i2=129    值传递机制
        System.out.println("i1=" + i1 + ", i2=" + i2);

        short a = 1; short b = 2;
        // java.lang.Integer: 3
        System.out.println(Chap01.getType(a + b)  + ": " + (a + b));
    }
}

实例变量与静态变量

• 实例变量：类的属性，没有标记为static的变量
• 静态变量：类的属性，标记为static的变量
• 区别：前者是每一个类的实例（对象）都有各自的实例变量，各个对象不能共用同一个实例变量，不能通过类点属性访问。后者是在存储在方法区的一个变量，一个类只有一份，在创建多个对象的时候，对象对应属性的引用指向方法区中的对应静态变量，多个对象使用的是同一个静态变量，可以通过类点属性访问。

private | protected | public

关键字\作用域	当前类	相同包	在当前包外的子类	当前项目
private	y	n	n	n
缺省	y	y	n	n
protected	y	y	y	n
public	y	y	y	y

static、final、abstract、synchronized、transient、volatile

• static：标记方法，属性为静态。
• final：修饰方法，变量和类，被修饰之后不能再做修改。
• abstract：抽象，用于抽象类和方法，方法的实现交给子类来完成。
• synchronized：同步，同步代码块与同步方法，使程序在多线程下访问同一个数据只能一个一个线程的访问。
• transient：当类被标记为Serializable(可序列化)时，有存在不想被序列化(持久化)的属性，可以使用。
• volatile：被修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。

一个简单的类

public class Chap03 {
    public static void main(String[] args) {
        // 创建一个Animal对象
        Animal animal = new Animal("喜鹊", 2, 12.5F);
        // Animal.feature： 静态属性可以直接通过类访问
        System.out.println("name: " + animal.name + "\nage: " + animal.age + "\nheight: " 
                +animal.height + "\nfeature: " + Animal.feature);
    }
}

// Animal 类
class Animal{
    // 属性/成员变量
    String name;
    int age;
    float height;
    public static String feature = "动物都会动";

    // 方法
    public Animal(String name, int age, float height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }
}