java基础

1.面向对象的三大特性

1.封装

概念：

封装是面向对象的一个重要原则，即利用抽象数据类型和基于数据的操作封装在一起构成一个独立的整体。数据被保护在抽象数据类型内部，对外提供服务尽可能的隐藏内部细节，只保留一些接口对外服务。用户在调用的时候无需关心内部的实现逻辑，只需要对象对外提供的接口来访问对象即可。

优点：

1.好的封装可以减少耦合性

2.减轻维护的负担，内部调节可以自由修改不受外部影响

3.提高方法的可重用性

4.降低了系统重构的风险性

5.隐藏内部的实现细节

如下面的代码片段，是把一个对象的属性私有化，同时提供一些方法被外部访问，getter和setter方法就是被外界访问获取属性值的接口

@Data
@AllArgsConstructor
public class Person {

    private int age;

    private String name;

    private String sex;

    private String phoneNumber;


}

2.继承

概念：

继承是java面向对象编程的一块基石，因为它允许创建分层次等级的类。继承就是子类继承父类的特征和行为，使得子类具有父类相同的行为和方法。被继承的类叫做父类或者超类，继承的类叫做子类或者派生类。

Cat是Animal的父类 Animal animal = new Cat() 父类的引用指向子类的对象成为向上转型 

继承实现了is-a的关系，extends和implements关键字用于描述java中的继承

继承的优点或者目的：

1.促进了代码的可用性，减少子类代码的书写，还可以继承父类的成员方法和成员变量

2.它通过方法的重写来呈现多态的性质

继承的缺点：

1.打破了类的封装的特性

2.耦合性太大

代码片段中man继承了Person，Person就是Man的超类

class Person
{
     public void p()
    {
        System.out.println("我是父类方法");
    }

}
class Man extends Person
{
     public void m()
    {
        System.out.println("我是子类方法");
    }

}

3.多态

概念：

多态是指同一操作用于不同的对象产生不同相应，即同一消息根据发送的不同的对象而采用的多种的不同行为方式。

多态氛围编译时多态和运行时多态：

编译时多态指得是方法的重载，如一个接口主的多个方法主要通过函数重载、运算重载（静态多态）和虚函数（动态多态）实现

运行时多态指的是在程序中定义的对象饮用指向的具体类型在运行期间才能确定

运行时多态的三种条件：

1.继承

2.重写/覆盖（重写是指子类重写父类的方法）

3.向上转型

伪代码如下：执行结果在animal调用eat方法时 ，实际上执行的是引用类所在的对象的方法

public class Animal {
    public void eat() {
        System.out.println("动物吃饭");
    }
}

public class Cat extends Animal {
    public void eat() {
        System.out.println("小猫吃鱼");
    }
}

public class Dog extends Animal {
    public void eat() {
        System.out.println("小狗吃肉");
    }
}

public class Music {
    public static void main(String[] args) {
        List<Animal> animals = new ArrayList<>();
        animals.add(new Cat());
        animals.add(new Dog());
        for(Animal animal : animals) {
            animal.eat();
        }
    }
}

2.java中面向对象的的六种关系 

1.泛化关系-Generalization

用来描述继承关系，在 Java 中使用 extends 关键字

2.实现关系-Realization

用来实现一个接口，在 Java 中使用 implement 关键字

3.聚合关系-Aggregation

表示整体由部分组成，但是整体和部分不是强依赖的，两者之间是has-a的关系,处于聚合关系的两个类的生命周期不同步

伪代码如下：

public class Human {
    Computer computer;
    Human(Computer computer1){
        computer=computer1;
    }
 
    public static void main(String[] args) {
        Computer c=new Computer();//聚合
        Human h=new Human(c);
    }
}
class Computer{
 
}

4.组合关系-Composition

组合也一种"Part-od"关系。它与聚合的区别是：聚合它不涉及拥有，两者是单独存在的，而组合关系是有拥有关系存在的，而且是强依赖的，即整体不存在了部分也不存在了

public class Person {
    Man man;
    public Person(){//组合
        man=new Man();
    }
 
    public static void main(String[] args) {
        Person person=new Person();
    }
 
}
class Man{
 
 }

5.关联关系-Association

表示不同类对象之间有关联，这是一种静态关系，与运行过程的状态无关，在最开始就可以确定。因此也可以用 1 对 1、多对 1、多对多这种关联关系来表示

public class Customer  
{  
    private Product[] products;  
    ……  
}  
public class Product  
{  
    private Customer customer;  
    ……  
}  
 

6.依赖关系-Dependency

和关联关系不同的是，依赖关系是在运行过程中起作用的 ，它是对象之间耦合度最弱的一种关联方式，是临时性的关联。在代码中，某个类的方法通过局部变量、方法的参数或者对静态方法的调用来访问另一个类（被依赖类）中的某些方法来完成一些职责

class Car { 
  public static void run(){ 
    System.out.println("汽车在奔跑"); 
  } 
} 
class Driver { 
  //使用形参方式发生依赖关系 
  public void drive1(Car car){ 
    car.run(); 
  } 
  //使用局部变量发生依赖关系 
  public void drive2(){ 
    Car car = new Car(); 
    car.run(); 
  } 
  //使用静态变量发生依赖关系 
  public void drive3(){ 
    Car.run(); 
  } 
}

总结：聚合和组合也是一种关联关系，所以关联、聚合、组合只能配合语义，结合上下文才能够判断出来