数据类型（类型转换、关键字等）和对象（应用与理解）_修饰什么修饰的数据不可以做类型转换-CSDN博客

本文链接：https://blog.csdn.net/weixin_43539011/article/details/123560987

1、基础语法

1.1、数据类型

1.1.1、Java数据类型

基本数据类型
- 数值型
  - 整数类型
    - byte —> Byte
    - short —> Short
    - int ----> Integer
    - long —> Long
  - 浮点类型(float,double)
  - float —> Float
  - double —> Double
- 字符型(char)
  - char —> Character
- 布尔型(boolean)
  - boolean —> Boolean
引用数据类型
- 类(class)
- 接口(interface)
- 数组([])

注意：

1、原始类型无法直接使用包装类里面的方法
2、原始数据不能为null，而包装类可以为null

数值型类型互转：

Byte zj = 0x0A;
System.out.println("方法1_Byte转Int结果 --> "+(int)zj);
System.out.println("方法2_Byte转Int结果 --> "+Integer.valueOf(zj));
System.out.println("方法3_Byte转Int结果 --> "+(zj&0xff));
System.out.println("方法4_Byte转Int结果 --> "+(zj));

Integer i = 20; //Double Float Integer String 都可以使用valueOf来互相转换类型，前提是数值
System.out.println("i转换为Double ---> " + Double.valueOf(i));
System.out.println("i转换为Float  ---> " + Float.valueOf(i));
System.out.println("i转换为String ---> " + String.valueOf(i));
System.out.println("i转换为String ---> " + i.toString());
System.out.println("i转换为String ---> " + i + "");

Boolean flag = false;
System.out.println("flag转String ---> "+ flag.toString());


Integer a = new Integer(3);
Integer b = 3;  // 将3自动装箱成Integer类型
int c = 3;
System.out.println(a == b); // false 两个引用没有引用同一对象
System.out.println(a == c); // true a自动拆箱成int类型再和c比较
System.out.println(b == c); // true

Integer a1 = 128;
Integer b1 = 128;
System.out.println(a1 == b1); // false

Integer a2 = 127;
Integer b2 = 127;
System.out.println(a2 == b2); // true

1.1.2、Math.round 四舍五入

System.out.println(Math.round(11.1));//返回值11
System.out.println(Math.round(11.2));//返回值11
System.out.println(Math.round(11.3));//返回值11
System.out.println(Math.round(11.4));//返回值11
System.out.println(Math.round(11.5));//返回值12
System.out.println(Math.round(11.6));//返回值12

1.1.3、编码

Java语言采用Unicode编码标准，Unicode（标准码），它为每个字符制订了一个唯一的数值

1.1.4、访问修饰符

定义：Java中，可以使用访问修饰符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

分类

private : 在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类）
default (即缺省，什么也不写，不使用任何关键字）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）。
public : 对所有类可见。使用对象：类、接口、变量、方法

在这里插入图片描述

1.1.5、关键词

1、final

final可以修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表示该变量是一个常量不能被重新赋值。

2、 this关键字的用法

this是自身的一个对象，代表对象本身，可以理解为：指向对象本身的一个指针。

this的用法在java中大体可以分为3种：

①. 普通的直接引用，this相当于是指向当前对象本身。

②. 形参与成员名字重名，用this来区分：

在这里插入图片描述

3、 static应用场景

因为static是被类的实例对象所共享，因此如果某个成员变量是被所有对象所共享的，那么这个成员变量就应该定义为静态变量。

因此比较常见的static应用场景有：

修饰成员变量
修饰成员方法
静态代码块
修饰类【只能修饰内部类也就是静态内部类】
静态导包

static注意事项

静态只能访问静态。
非静态既可以访问非静态的，也可以访问静态的。

2、面向对象

Object类是一切java类的父类，对于普通的java类，即便不声明，也是默认继承了Object类。

所有的类均默认继承了Object，下图是Object继承的父方法

在这里插入图片描述

面向对象的三大核心特性：

可重用性：代码重复使用，减少代码量，提高开发效率。面向对象的三大基本特征（继承、封装和多态）都围绕这个核心。
可扩展性：指新的功能可以很容易地加入到系统中来，便于软件的修改。
客观理性：能够将功能与数据结合，方便管理。

2.2、类

类：用来描述一类具有相同特征（属性）和相同行为（方法）的对象。（可以比喻为模板）

Java中用class关键字来描述类
- 成员属性（变量）：对应的就是事物的属性
- 成员方法：对象事物的行为

2.2、继承

继承的特点：

继承要有一定的层次结构，而且还要具备一定的可传递性
- 子类继承了父类的所有属性和方法，但是不包括私有属性（private）和构造方法
- 子类继承父类的属性和方法同时也可以有自己的属性和方法。
- Java 只支持单继承。也就是说一个子类只能有一个父类，父类可以有多个子类
继承可以减少重复代码、提高了复用性和维护性
继承让类与类之间产生了关系，类的耦合性增强了，父类发生变化子类也会跟着改变

继承的好处和弊端
好处：

提高了代码的复用性（多个类相同的成员可以放到一个类当中）
提高了代码的维护性（如果方法的代码需要修改，只需修改一处即可）

弊端：

继承让类与类之间产生了关系，类的耦合性也增加了，当父类发送变化时候，子类也不得不跟着变化，削弱了子类的独立性。
所以继承的使用需要考虑周全，那么什么时候使用继承比较好呢？
继承关系的体现：is a
假设法：我有两个类A和B，如果满足A是B的一种，或者B是A的一种，就说明他们存在继承关系，这个时候就可以考虑使用继承，否则不能滥用继承

2.3、重写

重写的的前提是继承父类

概述：

子类中出现了和父类一模一样的声明
当子类需要父类的功能，而功能主体中，子类有自己独特的内容，就可以通过重写父类中的方法，这样，即沿袭了父类的功能，又定义了自己的特有内容

方法重写的注意事项：

父类中的私有内容是无法重写的（private修饰）
子类重写父类方法的时候，方法访问权限不能低于父类方法的访问权限
（访问权限：public>默认（即不写修饰符）>private）

2.4、重载

重载（overload）：在同一个类中，允许存在一个以上的同名函数，只要他们的参数个数或者参数类型不同即可。比如，如果没有重载，我们在写求和这个方法时，必须写一个对整数的，再写一个对小数的。这样非常麻烦且不易调用。但有了重载以后，我们可以把对整数和小数的求和整合到一个方法中，不论往里面传的是小数还是整数都可以通过一次调用解决。

特点：与返回值类型无关，只看参数列表（参数的个数、参数的类型、参数的顺序）。

//父类
public class Animal {
    private String name;//名称
    private int month;//月份
    private String species;//种类
    
    //构造器重载
    public Animal(){}
    
    public Animal(String name){
        this.name = name;
    }
    public Animal(String name,String species){
        this.name = name;
        this.species = species;
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public String getSpecies() {
        return species;
    }

    public void setSpecies(String species) {
        this.species = species;
    }
}

//子类
public class Dog extends Animal{
    public String run(){
        return (this.getName()+"在跑步是一条"+this.getSpecies());
    }
    public void setName(String name,String ss) {
        this.setName(name);
        this.setSpecies(ss);
        System.out.println("狗类使用了重载");
    }
}

//子类
public class Mao extends Animal{
    public String sleep(){
        return (this.getName()+"在睡觉是一条"+this.getSpecies());
    }
    @Override
    public String getName() {
        System.out.println("我重写了Animal的方法");
        return super.getName();
    }
}
public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("小狗狗","狗");
        System.out.println(dog.run());

        Mao mao = new Mao();
        mao.setName("小猫猫");
        mao.setSpecies("猫");
        System.out.println(mao.sleep());

        Animal dog_2 = new Dog();
        Dog dog_3 = (Dog) dog_2;
        System.out.println("使用了多态，并向下强制转型使用子类特有的方法");
        dog_3.setName("小狗","红狗");
        System.out.println(dog_3.run());
        //dog_2.setName("小狗","狗1"); 无法调用，语法错误，多态不使用强制向下转型就无法使用子类特有的方法
        //System.out.println(dog_2.run());
}
//狗类使用了重载
//小狗狗在跑步是一条狗
//我重写了Animal的方法
//小猫猫在睡觉是一条猫
//使用了多态，并向下强制转型使用子类特有的方法
//狗类使用了重载
//小狗在跑步是一条红狗