Java学习-基础

Java 学习-基础-01

1. 什么是面向对象，面向对象和面向过程的区别

面向对象和面向过程都是一种软件开发思想。

什么是面向对象： 面向对象是把构成问题事物分解成各个对象，分别设计这些对象，然后将它们组装成完整功能的系统。

区别： 面向过程分析出解决问题的步骤，用函数按步骤实现，使用时依次调用就函数；面向对象时用类实现各个功能模块。

---

2.面向对象三大特性

• 封装
• 继承
• 多态

封装

利用 抽象数据类型 将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体。数据被保护在 抽象数据类型 的内部，尽可能地隐藏内部细节，只保留一些对外接口使之与外部发生联系。用户无需知道对象内部的细节，但可以通过对象对外提供的接口访问该对象。

优点：

• 减少耦合：可以独立地开发、测试、优化、使用、理解和修改
• 减轻维护的负担：可以更容易被程序员理解，并且在调试的时候可以不影响其他模块
• 有效的调节性能：可以通过剖析确定哪些模块影响了系统的性能
• 提高软件的可重用性
• 降低了构建大型系统的风险：即使整个系统不可用，但是这些独立的模块却有可能是可用的

继承

继承就是子类继承父类的特征和行为，使得子类（派生类）可以从父类（基类）继承特征和行为，从而使得子类（派生类）可以复用父类（基类）的代码。

//  父类
class Animal{
    public void eat(){
        System.out.println("吃东西");
    }
}

//  子类
class Cat extend Animal{
    public void eat(){
        System.out.println("猫吃东西");
    }
}

Anilmal animal = new Cat();

继承的特性

• 子类拥有父类非私有的属性和方法
• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展
• 子类可以用自己的方式实现父类的方法，即子类可以覆盖父类的方法
• 子类可以继承父类的构造函数，子类可以用自己的构造函数来覆盖父类的构造函数
• Java 的继承是单继承
• 提高了类之间的耦合度，使得类之间的关系更加清晰

多态

多态分为编译时多态和运行时多态

• 编译时多态主要指方法的重载，即方法的重写
• 运行时多态，指的是程序中定义的对象引用所指向的具体类型，在运行期间才确定。

//  父类
class Animal{
    public void eat(){
        System.out.println("吃东西");
    }
}

//  子类
class Cat extend Animal{
    //  编译时多态
    public void eat(){
        System.out.println("猫吃东西");
    }
}

Anilmal animal = new Cat();
//  运行时多态
animal.eat();

---

3.JDK JRE JVM

JDK Java Development Kit,即 Java 开发工具包，用于编译 Java 程序
JRE Java Runtime Environment,即 Java 运行环境，用于运行 Java 程序
JVM Java Virtual Machine,即 Java 虚拟机,是 Java 实现跨平台最核心的部分。用于运行 Java 程序。

---

4.==和 equals 比较

== 对于基本类型是值的比较，对于引用类型是地址的比较
equals 默认是引用比较，但很多类会重写 equals 方法，使之成为值的比较，如 String，Integer，Double 等。

---

5.hashCode 和 equals

结论：

• hashCode 相等，equals 不一定相等
• hashCode 不相等，equals 一定不相等
• equals 相等，hashCode 一定相等
• equals 不相等，hashCode 一定不相等

Integer aInt = 97;
Integer aStr = "a";

System.out.println(aInt.hashCode());
System.out.println(aStr.hashCode());

输出值都是 97

重写 equals 必须重写 hashCode:需要遵循 equals 相等，hashCode 一定相等

---

6.final

• final 关键字，用于修饰类，方法，属性，变量，表达式，类型等
• final 修饰的累叫做最终类，该累不能被继承（String）
• final 修饰的方法不能被重写
• final 修饰的变量叫常量，必须初始化，不能被修改

---

7.String、StringBuffer、StringBuilder

String: 字符串类，用于存储字符串，不可变，线程安全
StringBuffer: 字符串缓冲区，用于存储字符串，可变，线程安全
StringBuilder: 字符串构造器，用于存储字符串，可变，线程不安全

StringBuffer 实现方法里，通过使用 Syncronized 来保证线程安全
StringBuilder 没有使用 Syncronized，线程不安全

---

8.基础数据类型

基础数据类型: byte, short, int, long, float, double, char, boolean
自动转型是从低到高、高到低必须强转。

---

9.重载和重写的区别

• 重写(Override)：

方法名相同，方法参数相同，返回类型相同。一个在父类，一个在子类。

• 重载(Overload)：

方法名相同，方法参数不相同，返回值可以不同，用于同一类内。

---

10.接口和抽象类的区别

抽象类：
抽象类是用来描述抽象行为的。比如 Animal，我们并不知道具体会有哪些行为，只有具体的动物，如 Cat、Dog 才具有行为，才能够被实例化。抽象类是实现多态的一种机制，它可以包含具体的方法。也可以包含抽象方法，而继承它的子类必须实现这些抽线方法。
抽象类具有一下特性：

1. 抽象类不能被实例化，但可以有构造函数
2. 抽象方法必须由子类进行重写
3. 只要包含一个抽象方法，就必须定义为抽象类
4. 抽象类中可以包含具体的方法，也可以不包含抽象方法
5. 抽象类可以包含普通的成员变量
6. 抽象类也可以包含静态成员变量
7. 子类中的抽象方法，不能与父类的抽象方法相同
8. abstract 不能与 private、static、final、native 共同使用

接口：
接口通过 interface 关键字实现，接口不是类，因此不能实例化。实现类实现接口，必须实现接口所有方法。

接口是抽象类的延伸，Java 不能多重继承，但是可以多重实现接口。
接口有一下特性：

1. 接口中不能有构造方法
2. 接口的所有方法自动被声明为 public，而且只能是 public，使用其他会导致编译错误
3. 接口可以定义“成员变量”，而且会自动转化
4. 接口所有方法都是抽象的，不能有方法体，也不能包含静态方法
5. 实现接口的非抽象类必须实现接口的所有方法，而抽象类不用
6. 不能使用new关键字实例化接口，因为接口是不能实例化的
7. 在实现多接口的时候，一定要注意方法名的重复，否则会导致编译错误

总结：

1. 抽象类是一种继承管理，一个类只能有一个父类，但可以有多个接口
2. 在抽象类中可以拥有自己的成员变量和非抽象方法，但接口只能存在静态的不可变的成员数据，切接口的所有方法都是抽象的。
3. 抽象类和接口所反映的设计理念是不同的。抽象类代表的是“is-a”关系，而接口代表的是“like-a”的关系。

---