Java基础（1）

Java基础（1）

基础语法

1，增强型for循环：foreach

for(int i:arr){
    System.out.println(n);
}

2，方法的重写与重载：

重载：同类中名称相同，参数列表不同的方法。

重写：子类重新定义父类的方法，只允许访问修饰符改变。

3，数组的传值

数组传递进方法里面，方法指向了传进来的数组，所以在方法里面改变了数组的值，主方法里面的数值的值也会改变，因为指向同一个数组。

基本数据类型的值，方法里面改变了，主方法里面不变；

引用数据类型的值，方法里面改变了，主方法里面也会变化，因为是引用的，由始至终都是用到那个数据。

面向对象

1，面向对象特性：封装，多态，继承。

2，设计模式的七大原则：

开闭原则，里氏代换原则，依赖倒转原则，接口隔离原则；
迪米特法则，合成复用原则，单一职责原则。

# 1、开闭原则（Open Close Principle）

开闭原则的意思是：**对扩展开放，对修改关闭**。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

# 2、里氏代换原则（Liskov Substitution Principle）

里氏代换原则是面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP  是继承复用的基石，只有当派生类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

# 3、依赖倒转原则（Dependence Inversion Principle）

这个原则是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。

# 4、接口隔离原则（Interface Segregation Principle）

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。它还有另外一个意思是：降低类之间的耦合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。

# 5、迪米特法则，又称最少知道原则（Demeter Principle）

最少知道原则是指：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。

# 6、合成复用原则（Composite Reuse Principle）

合成复用原则是指：尽量使用合成/聚合的方式，而不是使用继承。

# 7、单一职责原则（Single responsibility principle）

单一职责原则是指：一个类应该只有一个发生变化的原因，即一个类只负责一项职责。
如果一个类有多个职责，这些职责就耦合在了一起。当一个职责发生变化时，可能会影响其它的职责。另外，多个职责耦合在一起会影响复用性。
此原则的核心是解耦和增强内聚性。

3，成员变量的初始值：

基本类型：

• 0，0L，0.0f，0.0d，false，’\u0000’（char）

引用类型：

• null

注意：局部变量没有初始值，在方法内使用要先赋值。

4，访问修饰符

private：私有的。

public：公共的。

默认不写：当前包内所有类。

protected：当前包内所有类或者其子类。

5，super关键字

使用super关键字，可以调用父类的可访问的成员（属性、方法），但是不能调用父类的构造方法。

父类的构造不允许被继承，不允许被重写，很重要！！！

注意：父类的构造方法不允许被继承，不允许被重写，但是会影响子类对象的实例化过程。子类构造方法中，会调用父类的构造方法，默认调用的是父类的无参构造方法，使用super()调用父类允许被访问的其他构造方法。super()必须放在子类构造方法有效代码的第一行。

6，子类对象的实例化过程：

类的加载 --> 对象实例化

---

父类静态成员 --> 父类静态代码块 --> 子类静态成员 --> 子类静态代码块 -->

子类构造方法(star1)中 调用 父类构造方法(star2) --> 父类属性赋值 --> 父类构造代码块 --> 回到父类构造方法(end2) -->子类属性赋值 --> 子类构造代码块 --> 回到子类构造方法(end1)

---

静态成员（属性和方法）之间，按照顺序先后调用，谁在前面就先调用谁。

7，final关键字

final 限定类：说明这个类不能被继承，该类没有子类。写法：public final class Animal{} 或 final public class Animal{}
final 限定方法：说明这个类不能被子类重写（可以重载），但可以正常被子类继承使用。final 不能修饰构造方法。 写法：public final void eat() {}
final 限定方法内局部变量：因为不同于类变量，没有初始值，所以要在具体使用之前进行赋值，一旦赋值后就不允许被修改。写法：final int temp; temp = 12; 或者 final int temp = 12;
final 限定类中成员属性：一定要赋值，不赋值会报错，并且只能在3个过程中赋值（定义时直接初始化；构造方法；构造代码块）写法：public public int temp = 15;
final 限定引用数据类型（类，数组，接口）：实例化后就不允许重新修订“引用地址”，但是属性值可以修改。 写法：final Animal animal = new Animal(“帆帆”,1);animal = new Animal(); XXXXXXXXX不允许这样做！！！animal.month = 12;animal.name = “豆豆”;
final 和 static ：静态的不允许被修改的信息（比如配置信息）。

8，注解

@override -->称为注解，可以验证重写方法。

注解：可以声明在包、类、属性、方法、局部变量、方法参数等的前面，用来对这些元素进行说明、注释，JDK1.5版本引入的特性。

注解按照运行机制区分：源码注解、编译时注解、运行时注解。

源码注解：只在源码中存在，编译成.class文件就不存在了。

编译时注解：在源码和.class文件中都存在。

运行时注解：在运行阶段还起作用，甚至会影响运行逻辑的注解。（Spring框架注解：@Autowrite）

---

注解按照来源分：来自JDK的注解；来自第三方的注解；我们自己定义的注解。

**元注解：比较特殊，用于对注解进行注释的。

9，单例模式概念

单例模式目的：使得类的一个对象成为该类在系统中的唯一实例。

单例模式优点：

1. 在内存中只有一个对象，节省内存空间。
2. 避免频繁的创建销毁对象，提高性能。
3. 避免对共享资源的多重占用。

单例模式的缺点：

1. 拓展比较困难。
2. 如果实例化后的对象长期不利用，系统将默认当成垃圾进行回收，造成对象状态丢失。

单例模式适用场景：

1. 创建对象时占用资源过多，但同时又需要用到该类对象。
2. 对系统内资源要求统一读写，如读写配置信息。
3. 当多个实例存在可能引起程序逻辑错误，如号码生成器。

10，单例模式代码实现

单例模式要点：

1. 某个类只能有一个实例；
2. 必须自行创建实例；
3. 必须自行向整个系统提供这个实例。

单例模式实现：

1. 只提供私有private的构造方法。（在类外无法实例化，因为实例化要调用构造方法）
2. 在类中创建一个该类的静态static私有private对象。
3. 提供一个静态static公有方法用于创建、获取静态私有对象。

单例模式方案：

1. 饿汉式：创建对象的过程中就实例化。线程安全。

2. 懒汉式：静态公有方法中实例化。存在线程风险。

   解决方法：同步锁，双重校验锁，静态内部类，枚举。

11，多态

多态：允许不同类的对象对同一消息做出不同的响应。

多态可分为：

1. 编译时多态 --> 方法重载。
2. 运行时多态 --> 程序运行时动态决定调用哪个方法。

Java中说到的多态，一般指运行时多态。

多态的必要条件：

1. 满足继承关系。
2. 父类引用指向子类对象。

12，向上转型

向上转型/隐式转型/自动转型：

子类对象转型为父类对象，即父类引用指向子类实例（由小向大转）。

向上转型后可以调用：

1. 子类重写父类的方法
2. 父类派生的方法
3. 无法调用子类独有的方法。

13，向下转型 与 instanceof 关键字

向下转型/强制类型转换：

子类引用指向父类对象，此处必须进行强转，可以调用子类特有的方法。

必须满足以下条件：强转对象必须是转为的那个类的子类。（two instanceof Cat == true）

instanceof后面的那个类是 对象实例化时使用的类或者其父类。

two实例化时使用的是Cat类，Animal和Object是Cat的父类。

14，抽象类abstract

抽象类：不允许实例化，只能被继承，可以通过向上转型完成实例（初始化使用子类）。

写法：public abstract class Animal {} 或 abstract public class Animal {}

应用场景：某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。

作用：限制子类的设计随意性；避免无意义父类的实例化（具体干活的都是子类）。

15，抽象方法abstract

抽象方法：不允许包含方法体，并且子类必须重写这个方法（子类为抽象类的话就非必须）。

写法：public abstract void eat();

注意：包含抽象方法的类一定是抽象类，抽象类中可以没有抽象方法。

16，static、final、private是否能和abstract并存？

全都不能。

abstract方法必须要在子类中被重写；

private限定了方法只能在本类（父类）中被调用；

final限定了方法不能被子类重写；

static静态方法不能被子类重写。

17，接口interface与implements

接口通常大写I开头：IPhoto、INet。

接口的访问权限：public、默认。

接口中抽象方法可以不写abstract关键字。

访问修饰符默认public。

当类实现接口时，需要实现接口中的所有抽象方法，否则需要将该类设置为抽象类。

公共常量定义：public static final int TEMP=20;

接口中可以包含常量，int TEMP=20和上面是一样的 ，因为接口的常量默认带上public static final。

接口概念：

1. 接口定义了某一批类所需要遵守的规范
2. 接口不关心这些类的内部数据，也不关心这些类里的方法的实现细节，它只规定这些类里必须提供某些方法。

18，接口中的默认方法default、默认方法static

两个都是JDK1.8后新增的方法。

default：默认方法，可以带方法体。

可以在实现类中重写，并可以通过接口的引用调用。

写法：default void connection(){ …}

static：静态方法，可以带方法体

不可以在实现类中重写，但可以通过接口名调用。

写法：static viod stop(){…}

19，多接口同名默认方法处理方案

一个实现类如果调用了多个接口，没有继承类，并且多个接口中存在同名的默认方法，那么在实现类中就必须重写该方法，不然实现类不知道以哪个为准。

一个实现类如果调用了多个接口，并继承类了一个类，父类和多个接口中，都存在同名的默认方法，那么以父类的为准，如果子类重写了就以子类的为准。

20，内部类

内部类：在Java中，可以将一个类定义在另一个类或一个方法里面，这样的类称为内部类。

内部类好处：能更好的实现信息隐藏。

内部类类型：

1. 成员内部类
2. 静态内部类
3. 方法内部类
4. 匿名内部类

外部类：包含内部类的类叫做外部类。

21，成员内部类

成员内部类/普通内部类：最常见的内部类。

1. 成员内部类在外部使用的时候，无法直接实例化，需要借由外部类信息才能完成实例化。
2. 成员内部类的访问修饰符可以任意，但是访问范围会受到影响。
3. 成员内部类可以直接访问外部类的成员，如果出现同名属性，优先访问内部类中定义的。
4. 可以使用外部类.this.成员的方式，访问外部类中同名信息。
5. 外部类访问内部类信息，需要通过内部类实例，无法直接访问。
6. 内部类编译后以.class文件命名：外部类$内部类.class。
7. 问题：内部类中是否可以包含与外部类相同方法签名的方法？

22，静态内部类

静态内部类：用static方法修饰的内部类，是外部类所有对象共享的。可以不依赖外部类对象，直接创建。

1. 静态内部类中，只能直接访问外部类的静态成员，如果需要调用非静态成员，可以通过对象实例。
2. 静态内部类对象实例时，可以不依赖外部类对象。
3. 可以外部类.内部类.静态成员的方式，访问内部类中的静态成员。
4. 当内部类属性与外部类属性同名时，默认直接调用内部类中的成员（就近原则）。
5. 访问外部类中的静态属性：外部类.属性
6. 访问外部类中的非静态属性：new 外部类().属性

23，方法内部类

1. 定义在方法内部，作用范围也在方法内。
2. 和方法内部成员使用规则一样，class前部不可以加任何访问修饰符和static。
3. 类中不能包含静态成员。
4. 类中可以包含final，abstract修饰的成员。

24，匿名内部类

1. 没有类型名称，实例对象名称。
2. 编译后的文件命名：外部类$数字.class
3. 无法使用访问修饰符，abstract，static来修饰。
4. 无法编写构造方法，可以添加构造代码块。
5. 不能出现静态成员。
6. 可以实现接口，也可以继承父类，但是不可兼得。

数组

1，一维数组

创建数组的三种方式：

1. int[] intArray; -->声明
2. intArray = new int[5]; -->创建
3. int[] intArray = new int[5]; -->声明同时创建
4. int[] intArray = {1,2,3,4,5}; -->初始化（声明+赋值）

常用属性：

length：输出数组长度