1.封装

指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法

优点

  1. 良好的封装能够减少耦合
  2. 类内部的结构可以自由修改
  3. 可以对成员变量进行更精确的控制
  4. 隐藏信息，实现细节

诀窍

属性私有，get/set

私有：private

student类

public class Student {
    private int age;
    private String name;
    //alt+insert
    //this表示这个类
    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        //可以增加判断语句
        this.age = age;
    }

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

Appliction类调用student类

public class Appliction {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setName("小智");
        System.out.println(stu.getName());
    }


}

2.继承

本质是对某一批类的抽象，从而实现对现实世界更好的建模。所有的类都继承object.只有单继承，没有多继承。

权限控制表

修饰词 本类 同一个包的类 继承类 其他类
private √ × × ×
无（默认） √ √ × ×
protected √ √ √ ×
public √ √ √ √

继承的语法

 public  class 子类  extends  父类{}

访问表现

  1. private修饰的属性或方法为该类所特有，在任何其他类中都不能直接访问；
  2. default修饰的属性或方法具有包访问特性，同一个包中的其他类可以访问；
  3. protected修饰的属性或方法在同一个中的其他类可以访问，同时对于不在同一个包中的子类中也可以访问；
  4. public修饰的属性或方法外部类中都可以直接访问。
//父类
public class Person {

    public int money = 1_0000_0000;
    public void test(){
        System.out.println("my is person");
    }
}

//子类
public class Student extends Person {

}

super和this

this的用法

构造方法是创建java对象的重要途径,通过new关键字调用构造器时,构造器返回该类的对象,但是这个对手并不是完全由构造器负责创建. 创建一个对象分为如下四步:

  1. 分配对象空间,并将对象成员变量初始化为0或者null
  2. 执行属性值的显式初始化
  3. 执行构造方法
  4. 返回对象的地址给相关变量

this就是对象的地址

public class Student {
    String name = "xiaoou";

    public String getName() {
        return name;
    }

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

public static void main(String[] args) {
        Student student = new Student();
        String name = student.getName();
        System.out.println(name);
        String xiaozhi = student.eclass("xiaozhi");
        System.out.println(xiaozhi);
    }

super

注意点

  1. super调用父类的构造方法，必须在构造方法的第一个
  2. super必须只能出现在子类的方法或者构造方法中
  3. super和this不能同时调用构造函数

调用父类的字段

public class Person {
    //父类的protected成员是包内可见的，并且对子类可见
    protected   String name = "小欧";
}
public class Student extends Person{
    String name = "小智";

    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

调用父类的方法

public class Person {
    public void print(){
        System.out.println("person");
    }
}

//学生类继承person类，就会拥有父类的全部方法
public class Student extends Person{
    public void print(){
        System.out.println("student");
    }

    public void test1(){
        print();
        this.print();
        super.print();
    }
}

super调用构造器得先执行父类构造函数

public class Person {
    //构造函数
    public Person() {
        System.out.println("this is person");
    }
}

//学生类继承person类，就会拥有父类的全部方法
public class Student extends Person{
    //构造函数
    public Student() {
        //隐藏代码super()：调用父类的无参构造
        //super();//调用父类的构造器，必须要在子类构造器的第一行
        System.out.println("this is student");
    }
}
//输出结果
//this is person
//this is student

this和super的区别

代表的对象不同

  1. this:本身调用者这个对象
  2. super:代表父类对象的应用

前提

  1. this:没有继承也可以使用
  2. super：必须继承才能使用

构造方法

  1. this()本类的构造
  2. super()父类的构造

方法重写

必须有继承关系，与属性无关，子类重写父类的方法，子类的方法必须和父类一致：方法体不同

  1. 方法名必须相同
  2. 参数列表必须相同
  3. 修饰符：范围可以扩大但不能缩小：public>Protected>Defalt>private
  4. 抛出的异常：范围，可以被缩小，但不能扩大：ClassNotFoundException --> Exception（大）

IDEA重写快捷键ctrl+o

public class B {
    public void test(){
        System.out.println("hello world");
    }
}

public class A extends B {
    //重写Override(快捷键ctrl+o)
    @Override //注解
    public void test() {
        System.out.println("this is A");
    }
}

为什么需要重写方法？

父类的功能，子类不一定需要，或者不一定满足！

3.多态

  • 动态编译：类型：可扩展性
  • 同一个方法可以根据发送对象的不同采用多种不同的行为方式
  • 一个对象的实际类型是确认的，但可以指向对象的引用的类型有很多

多态存在的条件

  1. 有继承关系
  2. 子类重写父类方法
  3. 父类引用指向子类对象

注意：

  1. 多态是方法的多态，属性没有多态
  2. 父类和子类，有联系 类型转换异常！ClassCastException!
  3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象！
  4. 如果都存在该方法，就只执行子类的该方法

如果都存在该方法，就只执行子类的该方法（实例）

public class Person {

    protected  void run(){
        System.out.println("person");
    }


}

public class Student extends Person {
    @Override
    protected  void run() {
        System.out.println("student");
    }
}

没有多态的关键字（不能重写）

  1. static方法：属于类，它不属于实例（静态）
  2. final 常量
  3. private方法：私有的

instanceof和类型转换

instanceof

判断一个对象是什么类型

语法

对象 instanceof 类型

Object object = new Student();
 //判断是不是Student类型
System.out.println(object instanceof Student);//true

对象类型转换

  1. 父类引用指向子类的对象
  2. 把子类转换为父类，向上转换；
  3. 把父类转换为子类，向下转换：（强制转换）（可能丢失精度）
  4. 方便方法的调用，减少重复代码

原则和基本类型转换一致 高 -->低（强制转换）

public class Person {

}
public class Student extends Person {
    protected void eat(){
        System.out.println("小心心到吃东西");
    }
}

Student student = new Student();
Person person = new Student();
//类型转换
((Student)person).eat();

static关键字

static声明的成员变量为静态成员变量，也成为类变量 ，可以直接调用

应用

  1. 静态属性
  2. 静态方法
  3. 静态导入包
//静态属性（可以直接调用）
static int age = 10;//静态变量
int age1 = 10;//非静态变量

//静态方法（可以直接调用）
public void test(){
        System.out.println("this is 非静态方法");
    }

public static void test1(){
        System.out.println("this is 静态方法");
    }

//静态导入包
import static java.lang.Math.random;
public static void main(String[] args) {
        System.out.println(random());
    }

静态代码块 、匿名代码块 、构造方法执行顺序

public class Person {
    //第二
    //匿名代码块
    {
        System.out.println("匿名代码块");
    }
    //第一
    //静态代码块
    static {
        System.out.println("静态代码块");
    }
    //第三
    //构造方法
    public Person() {
        System.out.println("构造方法");
    }

    //执行顺序
    //1.静态代码块 2.匿名代码块 3.构造方法
    public static void main(String[] args) {
        Person person = new Person();

    }
}

先执行静态代码块，然后是匿名代码块，最后构造方法

静态代码块只执行一次，匿名代码块可以用来赋值