面向对象编程OOP

属性+方法=类

什么是面向对象

• 面向对象思想：物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后对某个分类下的细节进行面向过程的思索。适合处理复杂、需要多人协作的问题。
• 面向过程的思想：步骤清晰简单，适合处理一些较为简单的问题。
• 对于描述复杂的事物，为从宏观上把握，从整体上合理分析，需要使用面向对象的思路来分析整个系统。但具体到微观操作，仍需要面向过程的思路去处理。
• 面向对象编程的本质：以类的方式组织代码，以对象的组织（封装）数据。
• 抽象
• 三大特性：
  封装、继承、多态
• 从认识角度来说先有对象后有类。对象是具体的事物，类是抽象的（对对象的抽象）。
• 从代码运行角度考虑先有类再有对象。类是对象的模板。

//Demo01 类
public class Demo01 {
    //main方法
    public static void main(String[] args) {

    }
    /*
    修饰符 返回值类型 方法名(...){
        //方法体
        return 返回值；//return 结束方法，返回一个结果
    }
     */
    public String sayHello(){
        return"hello,world";
    }
    //没有返回值
    public void hello(){
        return;
    }
    //比大小
    public int max(int a,int b){
        return a>b?a:b;//三元运算符
    }
 }

方法的调用

• 静态方法和非静态方法

//Student类
public class Student {
    //静态方法
    public static void say1(){
        System.out.println("说话了");
    }
    //非静态方法
    public void say2(){
        System.out.println("说话了");
    }
}




public class Demo01 {
    //静态方法 static
    //非静态方法
    public static void main(String[] args) {
        Student.say1();//类名.方法名 静态方法
        //  非静态方法   实例化这个类 new
        //new Student().say2();
        Student student=new Student();//对象类型  对象名=对象值；
        student.say2();

    }
}

• 形参和实参

    public static void main(String[] args) {
        //实际参数和形式参数的类型要对应
        int add = new Demo01().add(1, 2);
        System.out.println(add);

    }
    public int add(int a, int b){
        return a+b;
    }

• 值传递和引用传递

//值传递
public class Demo01 {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);
        Demo01.change(a);
        System.out.println(a);// 1
    }
    //返回值为空
    public static void change(int a){
        a=10;
    }
}

//引用传递:对象  本质还是值传递
public class Demo01{
    public static void main(String[] args) {
        Person person=new Person();
        System.out.println(person.name);//null
        Demo01.change(person);
        System.out.println(person.name);//name

    }
    public static void change(Person person){
        person.name="name";//person是一个对象：指向的-->Person person=new Person()  这是一个具体的 可以改变属性
    }
}
//定义了一个Person类，有一个属性：name
class Person{
    String name;//null
}

类与对象的创建和使用

• 类与对象的关系
  类是一种抽象的数据类型，它是对某一类事物整体描述定义，但是并不能代表某一个具体的事物（例：Person类、Pet类 用来描述/定义某一类具体的事物应该具备的特点和行为）。静态的属性： 属性 动态的行为：方法
  对象是抽象概念的具体实例，能够体现出特点，展现出功能的是具体实例，而不是一个抽象的概念
• 使用new关键字创建对象
• 使用new关键字的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
• 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
  1. 必须和类的名字相同
  2. 必须没有返回类型，也不能写void
• 构造器作用：
  1. new 本质在调用构造方法
  2. 初始化对象的值
• 注意点
  1. 定义了有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
• Alt+Insert 快速生成
• 构造器必须要掌握
• 引用类型：基本类型（8）
  对象是通过引用来操作的：栈—>堆（地址）
• 对象的属性：字段Filed 成员变量
  默认初始化：
  • 数字：0 0.0
  • char: u0000
  • boolean: false
  • 引用：null
    修饰符 属性类型 属性名 = 属性值

//Student类
public class Student {
    //属性：字段
    String name;//null
    int age;//0
    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//一个项目应该只有一个main方法
public class Application {
    public static void main(String[] args) {
        //类：抽象的，实例化
        //类实例化后会返回一个自己的对象
        //student对象就是一个Student的具体实例
        Student xiaoming = new Student();//Alt+Enter只输后面 快速填充
        Student xiaohong = new Student();//Alt+Enter只输后面 快速填充
        xiaoming.name="小明";
        xiaoming.age=3;
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);


    }
}

//java--->class
public class Person {
    //一个类即使什么都不写，它也会存在一个方法
    //显示的定义构造器
    String name;
    //实例化初始值
    //构造器作用
    //1。使用new关键字必须要有构造器，本质是在调用构造器
    //2.用来初始化值
    public Person(){
    }
    //有参构造:一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name=name;
    }
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//一个项目应该只有一个main方法
public class Application {
    public static void main(String[] args) {
        //new 实例化了一个对象
        Person person = new Person("  ");
        System.out.println(person.name);//

    }
}

public class Pet {
    public String name;
    public int age;
    //无参构造
    public void shout(){
        System.out.println("叫了一声");
    }
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~``
//一个项目应该只有一个main方法
public class Application {
    public static void main(String[] args) {
        Pet dog = new Pet();
        dog.name="wc";
        dog.age=3;
        dog.shout();
        System.out.println(dog.name);
        System.out.println(dog.age);
    }
}

封装

• 该露的露，该藏得藏。追求高内聚，低耦合。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合，仅暴露少量的方法给外部使用。
• 封装（数据的隐藏）。通常应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
• 属性私有。get/set
• 封装的意义：
  1. 提高程序的安全性，保护数据
  2. 隐藏代码的实现细节
  3. 统一接口 get/set
  4. 系统可维护增加了

//类  private:私有
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 getAge(){
        return age;
    }
    public void setAge(int age){
        if(age>110 || age<0) {//不合法
            this.age = 3;
        }else{
            this.age=age;
        }
    }
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        String name = s1.getName();
        s1.setName("yg");
        System.out.println(s1.getName());
        s1.setAge(888);//不合法
        System.out.println(s1.getAge());
    }
}

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
• extends意思是“扩展”，子类是父类的扩展。
• Java中类只有单继承，没有多继承。
• 继承是类和类之间的一种关系，除此之外，类和类之间的继承关系还有依赖、组合、聚合等。
• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
• 子类和父类之间，从意义上讲应该具有“is a”的关系。
• public(优先级从上到下)
  protected
  default（默认的）
  private
• Ctrl+H
• 在Java中，所有的类都默认直接或者间接继承object
• super注意点
  1. super调用父类的构造方法，必须在构造方法的第一个
  2. super必须只能出现在子类的方法或者构造方法中
  3. super和this不能同时调用构造方法
  4. super和this的不同：
     代表的对象不同：this：本身调用者这个对象
     super：代表父类对象的应用
     前提：this：没有继承也可以使用
     super：只能在继承条件下才可以使用
     构造方法：this();本类的构造
     super();父类的构造

//学生 is 人  ：派生类，子类
//子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person {

}


//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//Person 人 ： 父类
public class Person {


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

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}












//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
public class Application{

    public static void main(String[] args) {
        Student student=new Student();
        student.say();
        System.out.println(student.getMoney());

        Person person =new Person();

    }

}

//Person 人 ： 父类
public class Person {
    public Person() {
        System.out.println("Person无参执行了");
    }

    protected String name="w";
    public void print(){
        System.out.println("Person");
    }
}


//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person {
    public Student() {
        //隐藏代码：调用了父类的无参构造
        //super();
        //调用父类的构造器必须要在子类构造器的第一行
        System.out.println("Student无参执行了");
    }

    private String name="j";
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);//输出了父类的name
    }
    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        print();
        this.print();//自己的
        super.print();//父类的
    }

}







//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
public class Application{
    public static void main(String[] args) {
        Student student=new Student();
        //student.test("y");
        // student.test1();

    }
}

• 方法的重写（和属性无关)
  • 静态方法和非静态方法区别很大：
    静态方法（static）:调用只和左边定义的数据类型有关(父类的引用指向了子类)
    非静态方法：可以重写 子类重写了父类的方法
  • 需要有继承关系，子类重写父类的方法
    1. 方法名必须相同
    2. 参数列表必须相同
    3. 修饰符：范围可以扩大，不能缩小 public>Protected>Default>private
    4. 抛出的异常：范围可以被缩小，但不能扩大
    5. 重写子类和父类的方法必须一致，但方法体不同
  • 重写的意义
    1. 父类的功能，子类不一定需要或不一定满足
    2. Alt+Insert: override;

public class B {
    public  void test(){
        System.out.println("B=>test()");
    }
}


//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
public class A extends B{
    //Override 重写
    @Override//注解：有功能的注释
    public void test() {
        System.out.println("A=>test()");
    }
}


//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
public class Application{
    public static void main(String[] args) {
        //方法的调用只和左边定义的数据类型有关
        //静态方法和非静态方法区别很大
        A a=new A();
        a.test();//A

        //父类的引用指向了子类
        B b=new A();//子类重写了父类的方法
        b.test();//B


    }
}

多态

• 动态编译：类型：可扩展性
• 一个对象的实际类型的实际类型是确定的，但可指向的引用类型不确定（父类的引用指向子类），但子类能调用的方法可以是自己的或者继承父类的，父类却不能调用子类独有的方法。简言之，对象能执行哪些方法，主要看对象左边的类型，和右边关系不大。
• 注意事项
  1. 多态是方法的多态，属性没有多态。
  2. 父类和子类之间要有联系才能转换（类型转换异常）ClassCastException!
  3. 多态存在的条件：继承关系，方法需要重写，父类引用指向子类对象 Father f1=new Son();
     - 不能被重写的方法：
     1. static,静态方法，属于类，不属于实例
     2. final 常量
     3. private方法（私有的）