Day07面向对象

目录

1.什么是面向对象

2.类与对象

3.构造器

4.Java三大特征：封装、继承、多态

1.封装

2.继承

3.方法重写

4.多态

5.instance of

6.抽象

7.接口

8.内部类

---

1.什么是面向对象

 

2.类与对象

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。

对象是抽象概念的具体实例。

例如动物是类

猫是动物类下的对象

3.构造器

1.构造器：

定义：1.名字和类名字相同

           2.没有返回值

作用：1.new关键字本质是在调用构造器方法

           2.初始化对象的值

注意点：1.在定义了有参构造方法以后，想要调用无参，必须要显示定义无参构造

例：

package com.Oop.Demo02;
//java------>class
public class Person {
//一个类即使什么都不写，它也会存在一个方法！
    //显示的定义构造器
    String name;
    int age;


    //1.使用new关键字，本质是在调用构造器
    //2.用来初始化值
    //public Person(){
        //实例化初始值
    //}

    //方法的重载，方法修饰符方法类方法名可以一样，参数不一样就是重载。
    //有参构造：一旦定义了有参构造，无参构造一定要显示定义
   // public Person(String name,int age){
        //有参构造
     //   this.name=name;
       // this.age=age;
    //}

    //Alt+insert快捷键自动生成构造器

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }
}

package com.Oop.Demo02;
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
       //new实例化了一个对象
        Person person = new Person("蒋铭基",18);
        System.out.println(person.name);
        System.out.println(person.age);

    }
}

原理图： 方法区也属于堆

/*
1.类与对象
类是一个模板：抽象的，对象是一个具体的实例！
 2.方法
 方法定义，调用
 3.对象的引用
 引用类型，基本类型（8）
 对象是通过引用来操作的：栈--->堆（地址）
 4.属性：字段（英文名Field）成员变量
     默认初始化：
     数字：0    0.0
     char: u0000
     boolean:false
     引用：null
命名方式：修饰符  属性类型  属性名 = 属性值
5.对象的创建和使用
    {1.必须使用new关键字创建对象，构造器   Person person =new Person();
    2.对象属性的使用: person.name;
       对象调用方法: person.sleep();
 6.类
 静态的属性    属性
 动态的行为    方法


         }



 */

4.Java三大特征：封装、继承、多态

1.封装

package com.Oop.Demo04;
//类    private:私有
/*封装的意义：
1.提高程序的安全性
2.隐藏代码的一些细节
3.统一接口
4.系统的可维护性增加了
 */
public class Student {
    //属性私有
    private String name; //名字
    private int id;//学号
    private char sex;//性别
    private int age;//年龄
    //学习()
    //睡觉()


    //提供一些可以操作这些属性的方法！
    //提供一些public的get、set方法
    //get获得这个属性的值
    public String getName(){
        return this.name;
    }
    //set设置这个属性的值
    public void setName(String name){
        this.name=name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return this.age;
    }

    public void setAge(int age) {
        if (age<120&&age>0) {
            this.age = age;
        }else {
            this.age = 3;
        }
    }
}

2.继承

package com.Oop.Demo05;
//Person 人   //父类
//在java中所有的类默认直接或间接继承Object类
public class Person {
    //四种修饰符
    /*1.public
      2.protected
      3.default
      4.private
     */

        public int money = 10_0000_0000;
       private int money2=10;
       public void say(){
           System.out.println("说了一句话");
       }

    public int getMoney2() {
        return money2;
    }

    public void setMoney2(int money2) {
        this.money2 = money2;
    }
}

package com.Oop.Demo05;
//学生 is 人  派生类 子类
//子类继承父类就会得到父类的除私有以外全部方法
public class Student extends Person{
    //ctrl+H打开类的树形结构

}

Super注意点：
            1.super是调用父类的构造方法，必须在构造方法中的第一个。
            2.super必须只能出现在子类的方法或者构造方法中。
            3.super和this 不能同时调用构造方法

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

3.方法重写

非静态方法只与前面定义的类型有关

方法重写是属于非静态方法的，子类继承父类下的重写 

重载：是方法同，方法名类型都可以同，但是参数不同

重写：是方法名类型都同，但方法不同。子类继承父类的一个方法，子类对父类方法的一个重写。                                    

方法重写总结：需要有继承的关系，子类重写父类的方法！
          1.方法名必须相同
          2.参数列表必须相同
          3.修饰符，范围可以扩大，但是不能缩小  public>Protected>default>private
          4.抛出的异常：范围可以被缩小，但不能被扩大：ClassNotFoundException -----> Exception(大);
      总之，重写方法，子类的方法名要和父类的方法名一致，方法体不同！

   为什么需要方法重写？
   1.父类的功能，子类不一定需要，或者不一定满足。

4.多态

/*
多态注意事项：
1.多态是方法的多态，属性没有多态。
2.父类和子类，有联系。{String ，Person}毫不相关：类型转换异常 ：ClassCastException！
3.存在条件：继承关系，方法需要重写，父类引用指向子类 ！Father f1=new Son();


重写回顾：
1.哪些方法不能被重写？
           1.static方法 属于类的，不属于实例;
           2.final   常量;
           3.private方法;



*/

5.instance of

判断一个对象是什么类型

package com.Oop.Demo08;



public class application {
    public static void main(String[] args) {
        //Object>String
        //Object>Person>Teacher
        //Object>Person>Student
        //左边绝对能否比较，右边判断一行是否相关
        Object object=new Student();
        System.out.println(object instanceof Student);//T
        System.out.println(object instanceof Person);//T
        System.out.println(object instanceof Object);//T
        System.out.println(object instanceof Teacher);//F
        System.out.println(object instanceof String);//F
        System.out.println("=========================");
        Person person = new Student();
        System.out.println(person instanceof Student);//T
        System.out.println(person instanceof Person);//T
        System.out.println(person instanceof Object);//T
        System.out.println(person instanceof Teacher);//F
        //System.out.println(person instanceof String);//编译报错
        System.out.println("==============================");
        Student student=new Student();
        System.out.println(student instanceof Student);//T
        System.out.println(student instanceof Person);//T
        System.out.println(student instanceof Object);//T
       // System.out.println(student instanceof Teacher);//编译报错
        //System.out.println(student instanceof String);//编译报错
        System.out.println("==========================");
        Teacher teacher=new Teacher();
        //System.out.println(teacher instanceof Student);//编译错误
        System.out.println(teacher instanceof Person);//T
        System.out.println(teacher instanceof Object);//T
        System.out.println(teacher instanceof Teacher);//T
        // System.out.println(teacher instanceof String);//编译错误


    }
}

代码块

package com.Oop.Demo09;

public class Person {

    {//功能：赋初始值
        System.out.println("匿名代码块");
        //匿名代码块
    }
   static {//只执行一次
       System.out.println("静态代码块");
        //静态代码块
    }
    public Person(){
        System.out.println("构造器加载");
    }

    public static void main(String[] args) {
        Person person =new Person();
        System.out.println("=================");
        Person person1 =new Person();
    }
}

6.抽象

被final修饰的类不能被继承

package com.Oop.Demo10;
//abstract 抽象类  ：类  只能单继承            Java  ：接口可以多继承
public abstract class Action {
    //约束·~有人帮我们实现
    public Action(){
        System.out.println("调用了抽象类的构造器");
    };
    //抽象方法。只有方法名字，没有方法的实现。
    public abstract void doSomething();
    //抽象类
    //1.不能new这个抽象类，只能靠子类去实现它：约束作用！
    //2.抽象类可以写普通方法
    //3.抽象方法必须在抽象类中
    //抽象的抽象

}

7.接口

接口：只有规范！自己无法写方法--专业的约束：约束和实现分离：面向接口编程 

接口的本质是契约。

接口作用：
          1.约束
          2.定义一些方法，让不同的人实现~10个人----->1个接口。
          3.常量 默认public static final
          4.方法 默认public abstract
          5.接口不能被实例化，接口没有构造方法
          6.implement可以实现多个接口
          7.必须要重写接口中的方法

8.内部类

1.成员内部类

2.静态内部类

3.局部内部类

 4.匿名内部类