Java学习Day04

面向对象

类与对象

类是对某一事物的抽象描述，它是对某一类事物的整体描述/定义，不指某个具体的事物；

• 动物、植物、手机、汽车
• Person类、Pet类、Car类等

对象是用于表示现实中该类事物的具体个体，是抽象概念的具体实例

• 张三就是 人 的一个具体实例，张三家里的旺财 就是 狗的一个具体实例
• 能够体现出特点，展现出功能的是具体的实例，而不是抽象的概念。

面向对象编程（Object-Oriented Programming，OOP）

面向对象编程的本质：以类的方式组织代码，以对象的组织（封装）数据。

三大特性

• 封装
• 继承
• 多态

1. 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
2. 从代码运行的角度考虑是先有类后有对象。类是对象的模板。

类的创建

定义格式

/*[修饰符] class 类名{
    //属性
    [成员变量定义] 
    [构造方法定义]
    [成员方法定义]
}
   []内部分可以缺省
*/

//学生类
public class Student {
    //属性：字段
    String name;
    int age;

    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}

创建与初始化对象

• 使用new关键字创建对象

类名 对象名称 = new 类名();

如：创建Person类的实例对象：

Person p = new Person();

简单的对象创建和使用

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //类→抽象的， 实例化
        //类实例化后会返回一个自己的对象；
        //Student对象就是一个Student类的具体实例！
        Student zhangsan = new Student();
        zhangsan.name = "张三";
        zhangsan.age = 19;
        zhangsan.study();
    }
}

张三今年19岁正在学习

构造器（构造方法）

一个类即使什么也不写，也会存在一个方法，即构造方法

• 方法名必须和类名相同
• 没有返回类型，也不能写void
• 一旦定义了有参构造，无参构造就必须显示定义

封装

属性私有，get/set

高内聚，低耦合

继承

extends的意思是”扩展"，子类 拓展 父类

JAVA中类只有单继承，没有多继承

私有属性无法继承

//父类
public class Master {
    protected String name = "蓝天";

}

//子类
public class Archer extends Master{

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

//测试类
public class Application {
    public static void main(String[] args) {
        //类→抽象的， 实例化
        //类实例化后会返回一个自己的对象；
        Archer archer = new Archer();
        archer.test("蓝Tian");

    }
}

测试结果

蓝Tian
Lantian
蓝天

Super关键词

super注意点:

1. super调用父类的构造方法，必须在构造方法的第一一个

2. super必须只能出现在子类的方法或者构造方法中!

3. super和 this不能同时调用构造方法!

Vs this:
代表的对象不同:
this:本身调用者这个对象
super:代表 父类对象的应用
前提
this:没有继承也可以使用
super:只能在继承条件才可以使用
构造方法
this() ; 本类的构造
super():父类的构造

//父类
public class Master {
    protected String name = "蓝天";

    public Master() {
        System.out.println("Master无参执行了");
    }
}


//子类
public class Archer extends Master{
    public Archer() {
        //默认有隐藏代码:super(); → 调用父类的无参构造
       // super(); 调用父类构造器，必须在子类构造器的第一行，且只能出现一次
        System.out.println("Archer无参构造被执行了");
    }

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

//测试类
public class Application {
    public static void main(String[] args) {
        //类→抽象的， 实例化
        //类实例化后会返回一个自己的对象；
        Archer archer = new Archer();
        archer.test("蓝Tian");

    }
}

执行结果

Master无参执行了
Archer无参构造被执行了
蓝Tian
Lantian
蓝天

多态

//父类
public class Master {

    public void skill(){
        System.out.println("技能释放");
    }
}

//子类1
public class Saber extends Master{
    @Override
    public void skill() {
        System.out.println("Saber释放了宝具EX咖喱棒！！！ ");
    }
    public  void result(){
        System.out.println("EX咖喱棒效果拔群");
    }
}

//子类2
public class Caster extends Master{
    @Override
    public void skill(){
        System.out.println("Caster释放了宝具Rule Breaker");
    }
    public  void result(){
        System.out.println("Rule Breaker效果拔群");
    }
}

//测试类
public class Application {
    public static void main(String[] args) {
    /*一个对象的实际类型是确定的
      new Saber();
      new Caster();
     */

        //可以指向的引用类型不确定；父类的引用指向子类
        Saber saber = new Saber();
        Caster caster = new Caster();
        Master saber1 = new Saber();    //创建Saber对象，使用Master类型的变量saber1引用
        Master caster1 = new Caster();  //创建Caster对象，使用Master类型的变量caster1引用

        //对象执行哪些方法，主要看等号左边的类型，和右边关系不大
        //saber1.result();  Master类中并没有result方法 所以无法执行


        saber1.skill();     //子类重写了父类的方法，执行子类的方法
        ((Saber)saber1).result();   //强制类型转换；将Master对象强制转换成Saber类型
        caster1.skill();
        ((Caster)caster1).result();
    }
}

结果

Saber释放了宝具EX咖喱棒！！！ 
EX咖喱棒效果拔群
Caster释放了宝具Rule Breaker
Rule Breaker效果拔群

多态注意事项

1. 多态是方法的多态，属性没有多态

2. 父类和子类之间；有联系 类型转换异常→ classCastException

3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象 Father f1 = new Son();

   不可重写的方法

   1. static 方法，属于类，不属于实例
   2. final 常量；
   3. private声明的方法；