封装

将事物的一些特点封装成属性 将行为封装成方法 将字段私有化 并对外提供访问方法

修饰符访问权限:

• public>protected>无修饰符(默认为default)>private

封装步骤

1. 把类中的字段私有化

2. 给每一个字段都提供一组getter setter方法 (方法的规范写法)；setXxx在测试类中尝试创建对象,并通过调用getter setter方法完成 对字段的赋值和取值

3. 提供一个无参数的构造方法

class Test5{
    public static void main(String[] args){
        Superman superman=new Superman();
        superman.setName("大便超人");
        System.out.println(superman.getName());
        superman.setAge(18);
        System.out.println(superman.getAge());
        superman.setSkill("大便轰炸");
        System.out.println(superman.getSkill());
    }
}

class Superman{
    //1.先将字段(属性)私有化
    private String name;
    private int age;
    private String skill;
    //2.定义访问方法
    public void setName(String n){
        name=n;
    }
    public String getName(){
        return name;
    }
    public void setAge(int a){
        age=a;
    }
    public int getAge(){
        return age;
    }
    public void setSkill(String s){
        skill=s;
    }
    public String getSkill(){
        return skill;
    }
}

• 方法名字：存值setName 取值getName : 特殊情况 布尔类型的字段get 变 is
• 参数：存值对应字段类型，取值不需要参数

继承

继承可以把父类的所有功能都直接拿过来，这样就不必重零做起，子类还可以新增自己特有的方法.

class A{ 
}
A 就是B的父类; B是A的子类
class B extends A{
}
//例子:
class Test1{
    public static void main(String[] args){
        Dog dog=new Dog();
        dog.run();
        System.out.println("hello");
    }
}

class Animal{//父类
    String name;
    int age;
    void run(){
        System.out.println("我在跑");
    }
}
class Dog extends Animal{   
}

可以继承的

• 非私有的属性和方法
• 特性

1. 私有的字段可以被继承 不能直接访问
2. 私有的方法可以被继承 不能直接访问
3. 构造方法是不能被继承的

不可继承的

构造方法不能被继承

特点

1. Java中类的继承只能够是单继承

2. 可以支持多重继承

3. 每一个类都有一个直接父类,如果没有看到显式的继承代码,那么就隐式继承就Object

方法覆写

• 子类中出现了和父类名字一样的成员(属性和方法)，子类的成员就重写了父类成员
• 子类对象如果存在相应的成员就不会再去父类中查找

为什么要覆写

• 当父类的方法不能满足子类的需求,就需要覆写方法来实现功能
• 子类方法是否在覆写父类的方法,可以通过注解@Override验证

class Test{
    public static void main(String[] args){
        System.out.println("hello");
        Bird bird=new Bird();
        bird.name="小花";
        bird.run();
    }
}
//子类方法是否在覆写父类的方法,可以通过注解@Override验证
class Animal{//父类
    String name;
    void run(){
        System.out.println(name+"跑得飞起");
    }
}
class Bird extends Animal{
    @Override//判断以下方法是否是方法重写
    void run(){
        System.out.println(name+"飞得贼快");
    }
}

注意

1. 保证子类方法和父类方法的方法签名(方法名+参数列表)一致;
2. 访问权限 : 子类方法的访问权限(修饰符)不能够比父类方法的访问权限更低;
3. 返回值类型 : 子类方法的返回值类型可以是父类方法的返回值类型的子类或者相等

Object类

Object是每一个类的，直接父类或者间接父类

• 每一个类都有一个直接父类,如果没有看到显示的继承代码,那么就隐式继承就Object
• Object所有类的根类,是一个非常重要的类,所有类的重要的公共的静态属性，及动态行为[方法]都被提取到了Object

Object中的方法

1. String toString() 返回调用此方法的当前对象的字符串表示形式(把当前对象转成字符串)
2. boolean equals(Object obj) 比较两个对象是否相等(比较调用此方法的对象是否和传入的obj”相等”)
3. int hashCode() 通过对象结合算法得到一个int值
4. Class<?> getClass() 返回此 Object 的运行时类(获得一个对象的真正的类型)

覆写toString方法

class Test{
    public static void main(String[] args){
        System.out.println("hello");
        Car car =new Car();
        car.name="宝马";
        car.price=250;
        System.out.println(car);
    }
}

class Car{
    String name;
    double price;
    //覆写toString
    public String toString(){
        return name+","+price;
    }
}

覆写equals方法

class Test{
    public static void main(String[] args){
        System.out.println("hello");
        Animal ani1= new Animal("小黑",2);
        Animal ani2=new Animal("小白",1);
        //比较两个对象的属性是否一致
        System.out.println(ani1.equals(ani2));
    }
}

class Animal{
    String name;
    int age;
    Animal(String name,int age){
        this.name=name;
        this.age=age;
    }
    //覆写equals方法
    public boolean equals(Object obj){
        //obj编译器只看类型不看值：obj为Object类型，没有name，age属性,所以进行强行转换
        Animal animal=(Animal) obj;
        return this.name.equals(animal.name)&&this.age==animal.age;
    }
}

==和equals的区别

• == (比较运算符)

  • 基本数据类型变量: 比较的就是值是否相等;
  • 引用数据类型变量: 比较的是对象的地址是否一样;（排除特殊 String）

• equals 方法[最初定义在根类Object中的,比较对象是否相等]

  • 基本数据类型 : 不能够使用! 基本数据类型不是对象,不能够调用Object中的方法
  • 引用数据类型 : 但是在Object的源码中定义的就是 == 进行比较比较

访问权限修饰符

• 访问权限从大到小: public> protected>默认不写(default)>private
• 主要是用来控制类和类中成员的访问权限

修饰范围

1. public和默认不写(default)可以修饰类(内部类和外部类)
2. private 和protected 不能够修饰类外部类
3. 都不能修饰局部变量

访问权限

应该怎么去用权限修饰符

1. 如果不希望别访问，私有化private权限

2. 如果希望别人访问，提供公共的权限public

3. 如果特殊情况：权限由小到大设置

多态

一种事物多种形态

编译的数据类型和运行的数据类型不一致的情况

语法

A a=new B();//多态

class A{}
class B extends B{}

多态实例

• 编译看左边,运行看右边,有static修饰运行也看左边
• 传递的参数类型可以是本类或本类的子类
• 返回值的类型可以为方法的返回值类型的子类

class Test{//多态
    public static void main(String[] args){
        System.out.println("hello");
        Animal one=new Person();
        one.eat();
    }
}
class Animal{
    void eat(){
        System.out.println("吃肉吃草吃自己");
    }
}
class Person extends Animal{
    void eat(){
        System.out.println("吃啥都行");
    }
}