JAVA基础巩固笔记| DAY 1

本文将会围绕 java基本类型 数组 方法 面向对象起步 四个方面展开

基本类型

java中内置八种数据类型， 而我们经常使用String并不属于基本类型，而是一个类，用来表示字符串。我们先来看下java中的八种数据类型。

---

byte

• 8位 有符号 以二进制表示的整数  
• 所以我们可以得知 表示符号占1位   表示数据大小的占7位 
• 可以计算出 范围是 (-2^7,2^7-1)
• 默认值为 0

short

• 16 位 有符号 二进制补码表示的整数 默认值为0
• 范围 -2^15，2^15-1

int

• 32位 有符号 二进制补码表示的整数 默认值为0
• 范围 -2^31，2^31-1

long

• 64位 有符号二进制补码表示的整数 默认值为0L
• 范围 -2^63，2^63-1
• 注意 long类型定义时必须加上字母L 否则编译器可能会尝试将其定为int类型来处理 导致数值溢出报错 例如 

long a=100000L;

 float

• 单精度 32位 有符号 
• 1位符号 8位指数位 32为尾数位
• 默认值0.0f

double

• 双精度 64位 有符号
• 1位符号位 8位指数位 23位尾数位

double d1 = 7D;  // D 表示这是一个 double 类型的字面量  
double d2 = 7.;  // 没有明确的后缀，但默认情况下，一个点后面的数字被认为是 double 类型的字面量  
double d3 = 8.0; // 这里的 0 暗示这是一个 double 类型的字面量，因为 float 类型的字面量通常不会带小数部分或者小数部分为0  
double d4 = 8.D; // 这里的 D 也是明确的 double 类型后缀  
double d5 = 12.9867; // 同样没有后缀，但默认为 double 类型

boolean

• 一位 默认值false
• 这种类型只能作为一种标志来记录true或false

char

• 16位表示Unicode字符  默认值'u0000'
• 可以存储任何字符

类型转换

当我们想要更改数据的类型时 我们可以对其进行类型转换 

类型转换可以分为两种

1.自动类型转换

2.强制类型转换

我们首先要清楚各种数据类型的级别大小

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

当 级别高  的数据转换成  级别较低 的数据时为 自动类型转换

自动类型转换不需要在程序中额外说明 直接使用即可 

char a='a';
int b=a;
//根据ASCII表 b的值会自动转换成 97

然而 当我们需要级别低的数据转化成级别高的数据时 就需要使用强制类型转换

int a=97；
char b=(char)a;
//所以b的值为'a'

注意 必须满足以下规则

1.  不能对boolean类型进行转换
2. 不能把对象类型转换成不相关类的对象
3. 转换过程中会出现精度缺失 浮点数到整数的转换会舍弃小数部分

数组

一种能够存储相同类型数据的数据结构

数组声明 

数组声明可以有多种方法 但是我们选用较为官方的一种进行讲解

数据类型[]  数组名；

创建数组

java创建数组必须使用 new 操作符 （你会发现在java中不论是数组还是对象都需要使用 new）

数组名=new 数据类型[数据大小];

将数组声明和创建合在一起就是

数据类型[] 数组名=new 数据类型[数组大小];

dataType[] arrayRefVar = new dataType[arraySize];

数组遍历

在java中 java提供了多种遍历数组的方式

我们来看更为使用的foreach循环（也称为增强for循环来遍历数组）

int[] array = {1, 2, 3, 4, 5};  
for (int num : array) {  
    System.out.println(num);  
}

在循环中 声明一个与数组类型一样类型的变量 这个变量在每次循环中就代表数组中的一个数据

相较于普通的for循环更简洁

int[] array = {1, 2, 3, 4, 5};  
for (int i = 0; i < array.length; i++) {  
    System.out.println(array[i]);  
}

然而foreach这种循环方式 只能遍历 无法在遍历的同时进行其他操作（例如 无法在遍历的同时删除数组中的某个数据 ）（集合的并发修改异常 ）

下面介绍一种更为专业的遍历方式

迭代器

int[] array = {1, 2, 3, 4, 5};  
List<Integer> list = Arrays.asList(array);  
Iterator<Integer> iterator = list.iterator();  
while (iterator.hasNext()) {  
    System.out.println(iterator.next());  
}

如果想要遍历的同时删除某个数据 可以使用迭代器自带的remove方法 

方法

在java中主方法是整个程序的入口点，主方法必须是 main 返回类型必须是void 并且要接收一个字符串数组

方法声明

在java中可以这么声明一个方法

修饰符 返回值类型 方法名称 参数列表 {

     方法体

}

方法调用

  public static int add(int a, int b) {  
        return a + b;  
    }  

该方法用static 修饰符修饰 可以在主程序中直接调用  

如果不加static修饰符 就需要创建包含该方法的类的对象 然后才能调用

例如

public class MyClass {  
  
 
   public  int add(int a, int b) {  
        return a + b;  
    }  


    public static void main(String[] args) {  
        // 创建 MyClass 类的对象  
        MyClass obj = new MyClass();  
        
       //调用对象的add方法
        int sum = obj.add(5, 10);  
        System.out.println("5 + 10 = " + sum);  
    }  
  
   
}

下面是一段static修饰符的解释

        在Java中，"static"关键字可以用来修饰类的属性、方法、代码块和内部类。当一个成员被声明为"static"时，它属于类本身，而不是类的任何特定对象。这意味着"static"成员在内存中只有一份，随着类的加载而加载，并且优先于对象存在。由于"static"成员属于类，因此它们可以被所有对象所共享，而无需创建类的对象即可直接通过类名来调用它们。

面向对象起步

java认为万物皆对象 所以在java编程中程序的一举一动都与对象有关 那么一个复杂的程序 就会有很多个对象 所以java中引入了一个类（Class）的概念 

类

有一个特性 我们可以将对象按照其自己的特性用类来分类

比如  动物类 ，小猫 小狗 小猴就是一个个的对象 

所以 对象就是类的实例化 是类的具体表现

在一个类中 通常包含以下几个部分

成员变量 

又称实例变量 它属于类中的所有对象 比如 年龄 身高 体重  这些属于小猫小狗小猴，我们可以在初始化对象时调用相应的方法分别赋值

（然而 局部变量 仅仅作用于方法中 方法执行完毕后局部变量就会销毁）

方法

相当于小猫小狗小猴的行为 

构造方法

是一种 特殊的方法 专门用来初始化新建的对象  注意 构造方法的名称必须与该类的名称相同 并且不能有返回值类型 在创建对象时 程序会自动调用构造方法 

我们有时也称为 构造器 一般分为两种 有参构造器和无参构造器    比如有参构造器在调用时可以直接在参数列表填入对应的值 来初始化对象

例如

public class Person {  
    // 成员变量  
    private String name;  
    private int age;  
  
    // 无参构造器  
    public Person() {  
        // 默认构造器，不执行任何特定初始化  
       
    }  
  
    // 有参构造器  
    public Person(String name, int age) {  
        // 通过参数初始化成员变量  
        this.name = name;  
        this.age = age;  
   
    }  
 } 

在new一个人对象时 使用有参构造会直接赋予这个对象相应的属性   如果使用无参构造器 想要赋予属性还需要进行别的操作

如果你定义了一个类 并没有给他定义一个构造方法 那么java会自动定义一个无参的构造器 方便你来通过这个类来 new出一个新对象  我们称为隐式构造方法

显然我们自己定义的构造方法称为 显式构造方法 如果你进行了显示构造 那么系统自带的隐式构造将不再生效  

---

三大特性

精髓  重在理解哈

继承

在已存在的类上建立新的类 也就是让子类继承父类  俗话就是 给儿子找爹 所以 一个儿子只能有一爹 也就是说 子类只能继承一个父类  但是一个爹可以有很多儿子 也就是可以被很多类继承

这样就有很多好处了

• 代码重用 子类继承父类的所有公有成员和保护成员 就是说 子类可以直接调用父类的方法 不需要自己重新写方法
• 扩展性  子类添加了父类有自己没有的新的属性和方法

注意了 Object是所有类的爹

封装

将对象的属性和行为隐藏在一个地方 就是对象里 然后其他程序不能随便访问 防止被随意更改

有三种修饰来控制

• protected

  • 本类，同一个包下的类，任意包的子类

• private

  • 仅限于在本类访问

• public

  • 任意访问 不用包下也可以被访问

• 缺省

  • 本类，同一个包的类

多态

允许我们以统一的方式处理不同类型的对象。多态性主要体现在方法重写（Method Overriding）和方法重载（Method Overloading）上，但通常我们所说的多态指的是方法重写所带来的多态性。

多态好处

• 多态形态下 右边对象 是解耦合 便于扩展维护

• 定义方法时 使用父类类型的形参 可以接收一切子类对象 扩展性更强 更便利

简简单单举个方法重写例子

// 父类 Animal  
class Animal {  
    public void speak() {  
        System.out.println("The animal speaks");  
    }  
}  
  
// 子类 Dog  
class Dog extends Animal {  
    @Override  
    public void speak() {  
        System.out.println("The dog barks");  
    }  
}  
  
// 子类 Cat  
class Cat extends Animal {  
    @Override  
    public void speak() {  
        System.out.println("The cat meows");  
    }  
}  
  
// 测试类  
public class TestAnimals {  
    public static void main(String[] args) {  
        // 创建一个 Animal 类型的数组  
        Animal[] animals = new Animal[2];  
          
        // 将 Dog 和 Cat 对象放入数组中  
        animals[0] = new Dog();  
        animals[1] = new Cat();  
          
        // 使用 for-each 循环遍历数组  
        for (Animal animal : animals) {  
            // 对数组中的每个对象调用 speak() 方法  
            // 由于多态，每个对象会调用自己重写的 speak() 方法  
            animal.speak();  
        }  
    }  
}