面向对象 -----Java

封装：

1.1什么是封装：

将类中的一些信息隐藏（对象的属性或者行为）在类中，不允许外部程序直接访问，（留出对外访问的接口）需要通过该类提供的特定方法对隐藏的属性或者行为进行访问。

1.2 封装的特点：

• 隐藏内部程序实现的细节
• 只能通过特定的方法进行访问

1.3 this关键字的用法

• 用于对象的引用

 public class Person{
     String name;
     String gender;
       public Person(String name,String gender){
       this.name=name;
       this.gender=gender;
  } 
}

• 调用本类的其他构造方法

this()调用的构造方法，只能在构造方法内调用其他的构造方法

public class Person{
     String name;
     String gender;
       public Person(String name,String gender){
       this.name=name;
       this.gender=gender;
  } 
  public Person(){
       this("name","gender"); //调用带两个参数的构造方法
  } 
}

• 当作方法的返回值

public class Solution {

     String name;
     public Solution set(String name){
           this.name=name;
           return this;
      }
}

继承

1.1 什么是继承：

子类继承父类的行为和属性
例如：
狗是动物的一个种类，那么狗有动物的共性。动物就是父类，狗就是子类

1.2 继承的特点：

• 一个子类只能继承一个父类，一个父类可以有多个子类
• 子类可以使用父类非私有的属性和方法，父类不能使用子类的属性和方法
• 创建子类对象首先调用父类的构造方法，再调用子类的构造方法

1.3 super关键字的用法：

• 调用父类的构造方法（只能在子类的构造方法中）（this()方法调用和super()不能同时使用）

• 子类调用同名的父类的方法

1.4 覆盖/重写

public class Animal {

     String name;
     public void enjoy(){
         System.out.print("jiao");
     }
}

class Dog extends Animal{
    @Override
    public void enjoy() {
        System.out.print("汪汪");
    }
}

在继承的基础下，重写父类的方法

子类的重写的方法的权限不能比父类更严格，返回值、参数列表、函数名都与父类方方法相同

1.5 重载

public class Animal {

    String name;
    public Animal(){
        
    }
    public Animal(String name) {
        this.name = name;
    }
}

在同一个类中，只是两个方法参数列表不同

1.6 重载与重写的区别：

重写： 在两个类中，方法名和参数列表都相同，子类重写的方法的权限不能比父类严格
重载： 在一个类中，方法名相同、参数列表不同，重载的方法对权限没有要求

1.7 访问修饰符有哪些，作用域是什么：

public ---- 只要在同一个项目中就可以访问到， 可以修饰类、方法、变量

default(不写关键字的时候默认为该权限) ---- 同一个包中就能访问，可以修饰类、方法、属性

protected ---- ① 同一个包中就能访问 ② 子类和父类在不同的包中，子类继承了父类的protected修饰的方法和属性，子类能访问 ，可以修饰方法、变量

private ---- 只能在本类中访问，修饰方法、变量

多态

1.1 什么是多态：

同一类对象的不同表现
例如：猫和狗都是属于动物，但是猫的叫声是喵，狗的叫声确实汪汪，从叫声来看猫和狗表现出了不同的方式

多态是指对象的多态，并非方法的多种形式，所以方法的重载并不是多态的表现形式。

1.2 多态的特点：

父类引用指向子类对象

使用多态的前提：
必须在继承的基础上，重写父类的方法

多态的使用注意： ① 父类引用不能访问子类独有的方法和属性 ② 父类引用调用方法时，该方法被子类重写过，则调用子类重写过的方法

public class Dog extends Animal{
    @Override
    public void enjoy() {
        System.out.println("汪汪");
    }
    
}

public class Animal {

    public void enjoy(){
        System.out.println("叫");
    }
    public static void main(String[] args) {
        Animal one=new Dog();
        one.enjoy();      //汪汪
    }  
}

1.3 引用数据类型的转型：

对象的向下转型 ---- 强制转换
对象的向上转型 ---- 自动转换

public class Animal {

    public void enjoy(){
        System.out.println("叫");
    }

    public static void main(String[] args) {
        Animal one=new Dog();   //对象的向上转型
        
        Dog two=(Dog)new Animal(); // 对象的向下转型
    }
}

class Dog extends Animal{
    @Override
    public void enjoy() {
        System.out.println("汪汪");
    }
}

static 关键字

1.1 用法：

修饰 内部类、方法、变量

1.2 特点

• 被static修饰的属性和方法可以直接使用类名调用
• 被static修饰的属性和方法被整个程序共享
• 静态方法不能够访问非静态的方法和属性，
• static修饰的方法和变量优先被加载，被static修饰的多个变量按照代码的顺序进行加载

1.3 静态代码块

 //静态代码块
 static{

 }
 //代码块
 {

 }

1.每次创建一个新的对象时，都会先执行代码块，再执行构造方法
2.每次程序的启动，只执行一次静态代码块，静态代码块优先于代码块的执行

创建对象时类的加载顺序

public class Animal {
    static int num;
    static{
        System.out.println("静态代码块");
    }
    {
        System.out.println("代码块");
    }
    public Animal(){
        System.out.println("构造方法");
    }
    public static void main(String[] args) {
       Animal one=new Animal();    
       /*
       *静态代码块
       *代码块
       *构造方法
       */
    }
}

public class Animal {
    private static Animal one = new Animal();
   
    static{
        System.out.println("静态代码块");
    }
    
    {
        System.out.println("代码块");
    }
    private Animal(){
        System.out.println("构造方法");
    }
    public static void main(String[] args) {
      /*
       *代码块
       *构造方法
       *静态代码块
       */
    }
}

final关键字

• 修饰类：被final修饰的类不能够有子类，不能够被其他类继承
• 修饰方法：方法不能够被重写
• 修饰变量：变量一旦被赋值就不能够被修改

抽象类

抽象是面向对象的特点之一

被abstract修饰的类叫做抽象类

特点：

• 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
• 抽象类不能被直接实例化，需要通过继承该抽象类，实例化子类
• 非抽象子类继承抽象类，就必须重写抽象类中的抽象方法