java面向对象

封装

封装的优点

1. 良好的封装能够减少耦合。

2. 类内部的结构可以自由修改。

3. 可以对成员变量进行更精确的控制。

4. 隐藏信息，实现细节。

简单封装(修改属性的可见性来限制对属性的访问（一般限制为private）)

name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了

public class Person {
    private String name;
    private int age;
}

提供访问(采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。)

快捷键ALT+insert

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

引用可省略(常对数据库引用)

import lombok.Data;
@Data
//设置关联表名
//@TableName()
public class user {

//    在实体类中uid属性上通过@TableId将其标识为主键，即可成功执行SQL语句
    private long id;
    private String password;
    private String username;
}

继承(在java中只能单继承)extends,减少代码臃肿

类的继承格式
class 父类 {
}
 
class 子类 extends 父类 {
}

继承的特性

子类拥有父类非 private 的属性、方法。

子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

子类可以用自己的方式实现父类的方法。

Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。

提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

super 与 this 关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用。

class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
 
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}
 
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eatTest();
  }
}

(Override)重写就是子类重新覆盖父类方法，通过子类构造器调用调用是子类的该方法

加上@Override可以让编译器帮助检查是否进行了正确的覆写

多态(方法)

简单理解就是父类或是继承接口的多种不同状态

• 多态是同一个行为具有多个不同表现形式或形态的能力。

• 多态就是同一个接口，使用不同的实例而执行不同操作。

• 多态性是对象多种表现形式的体现。

多态的优点

1. 消除类型之间的耦合关系

2. 可替换性

3. 可扩充性

4. 接口性

5. 灵活性

6. 简化性

       class A {
            void draw() {}
        }

        class B extends A {
            void draw() {
                System.out.println("我是B");
            }
        }

        class C extends A {
            void draw() {
                System.out.println("我是C");
            }
        }
        A b = new B();
        b.draw();//我是B
        A c = new C();
        c.draw();//我是C

多态的转型

多态的转型分为向上转型和向下转型两种

向上转型：多态本身就是向上转型过的过程

使用格式：父类类型 变量名=new 子类类型();

适用场景：当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作。

向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用类型转为子类引用各类型

使用格式：子类类型 变量名=（子类类型） 父类类型的变量；

适用场景：当要使用子类特有功能时。

接口（Interface）不是类(可以用多继承)

接口特性

• 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。

• 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。

• 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

接口与类的区别：

• 接口不能用于实例化对象。

• 接口没有构造方法。

• 接口中所有的方法必须是抽象方法，Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法。

• 接口不能包含成员变量，除了 static 和 final 变量。

• 接口不是被类继承了，而是要被类实现。

• 接口支持多继承。

interface Animal {
   public void eat();
   public void travel();
}

欢迎指导纠正！！！😀