什么是面向对象，如果你想知道什么是面向对象的话，我现在就带你一起研究（一）

面向对象编程 Java的核心思想就是opp 面向过程&面向对象面向过程思想步骤清晰简单，第一步做什么，第二步做什么面向过程适合处理一些较为简单的

面向对象编程

Java的核心思想就是opp

面向过程&面向对象

面向过程思想
- 步骤清晰简单，第一步做什么，第二步做什么......
- 面向过程适合处理一些较为简单的问题
面向对象思想
- 物以类聚，分类的思维模式，思考问题首先学会解决问题需要那些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

面向对象编程（oop）
面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据
抽象
三大特性：
- 封装
- 继承
- 多态
从认识论角度考虑是现有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
从代码运行角度考虑是现有类后有对象。类是对象的模板。

回顾方法及加深

方法的定义
- 修饰符
- 返回值类型
- break和return的区别
  - 前者出switch，循环结束后者代表该方法结束，返回一个结果
- 方法名：注意规范就ok 见名知意
- 参数列表：（参数类型，参数名）...
- 异常抛出
方法的调用：递归
- 静态方法
- 非静态方法
- 形参和实参
- 值传递和引用传递
- this关键字

#修饰符 返回值类型
package com.baidu.oop.demo01;

import java.io.IOException;

//Demo01 类
public class Demo01 {

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

    }
    /*
    修饰符 返回值类型  方法名(...){
        //方法体
        return 返回值;
    }
     */


    public String sayHello(){
        return "helloworld";
    }

    public int max(int a,int b){
       return a>b ? a : b;//三元运算符
    }

    //数组下标越界：Arrayindexoutofbounds
    public  void readFile(String file) throws IOException {

    }
}

#值传递和引用传递
    package com.baidu.oop.demo01;

//值传递
public class Demo04 {
    public static void main(String[] args) {
        int a = 1;

        System.out.println(a);//1

        Demo04.change(a);

        System.out.println(a);//1
    }

    public static void change(int a){
        a = 10;
    }
}
---------------------------------------------.package com.baidu.oop.demo01;

//引用传递：对象，本质还是值传递
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();

        System.out.println(person.name);//null

        Demo05.change(person);

        System.out.println(person.name);//韩锁

    }

    public static void change(Person person) {
        //person是一个对象，指向的是--->Person person = new Person();z这是一个具体的人，可以改变属性！
        person.name = "韩锁";
    }

}

//定义了一个Person类，有一个属性
class Person{
    String name;//null
}

类和对象的关系

类是一种抽象的数据类型，他是对某一事物的整体描述/定义，但是并不能代表某一个具体的事物
- 动物、植物、手机、电脑......
- Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
对象是抽象概念的具体实例
- 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例.
- 能够体现出提点，展现出功能的是具体的实例，而不是一个抽象的概念.

创建与初始化对象

使用new关键字创建对象
使用new关键字创建的时候，处理分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类种构造器的调用
类中的构造器也成为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有一下两个特点：
- 必须和类的名字相同
- 必须梅伊欧返回类型，也不能写void
构造器必须要掌握

package com.baidu.oop.demo02;

//学生类
public class Student {

    //属性：字段
    String name;
    int age;

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

}
//测试类
package com.baidu.oop.demo02;

public class Application {

    public static void main(String[] args) {
        //类：抽象的，实例化
        //类实例化后会返回一个自己的对象
        //student对象就是一个Student类的集体实例！
        Student xiaoming = new Student();
        Student xh = new Student();

        xiaoming.name = "小明";
        xiaoming.age = 3;

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

        xh.name="小红";
        xh.age=3;

        System.out.println(xh.name);
        System.out.println(xh.age);

    }
}

构造器

package com.baidu.oop.demo02;

public class Person {

    //一个类即使什么都不写，它也会存在一个方法
    //显示的定义构造器

    String name;

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

    //有参构造:一旦定义了有参构造，无参就必须显示定义

    public Person(String name) {
        this.name = name;
    }
}
//alt + insert 可以自动生成构造器

//测试类
package com.baidu.oop.demo02;

//一个项目应该只存在一个main方法
public class Application {

    public static void main(String[] args) {

        //new 实例化了一个对象
        Person person = new Person();

        System.out.println(person.name);
    }
}
/*
总结
构造器：
    1.和类名相同
    2.没有返回值
作用：
    1.new本质就是在调用构造方法
    2.初始化对象的值
注意点：
    1.定义有参构造之后，如果想用无参构造，就需要显示的定义一个无参的构造
    2.Alt + insert

    this. = 
 */

package com.baidu.oop.demo03;

public class Pet {
    public String name;
    public int age;

    //无参构造

    public void shout(){
        System.out.println("叫了一声");
    }
}
//测试类
package com.baidu.oop.demo03;

public class Application {
    public static void main(String[] args) {

        Pet dog = new Pet();
        dog.name = "旺财";
        dog.age = 3;
        dog.shout();

        System.out.println(dog.name);
        System.out.println(dog.age);
    }
}

内存图解

类和对象小结

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


封装 继承 多态
 */

封装

该露的露，该藏的藏
- 我们常需设计要追求，“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成。不允许外部干涉；低耦合：仅暴漏少量的方法给外部使用。
封装（数据的隐藏）
- 通常，应禁止访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
记住这句话就够了：属性私有，get/set

import com.baidu.oop.demo04.Student;

/*
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统可维护增加了
 */
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();

        s1.setName("韩锁");

        //方法名，参数列表
        System.out.println(s1.getName());

        s1.setAge(-1);//不合法
        System.out.println(s1.getAge());
    }

    //alt+insert
}

继承

继承的本质是对某一批类的抽象。从而实现对现实世界更好建模
extents的意思是“扩展”。子类是弗雷的扩展。
Java中类只有单继承，没有多继承！(一个儿子只能有一个爸爸，但是一个爸爸可以有多个儿子)
继承是类和类之间的一种关系。除此以外，类和类之间的关系还有依赖，组合，聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends类表示。
子类和父类之间，从意义上讲应该具有“is a”的关系
object类
super
方法重写

    //静态方法和非静态方法的区别很大
    //静态方法：方法的调用只能和左边，定义的数据类型有关
    
    //非静态：重写
    public static void main(String[] args) {


        A a = new A();
        a.test();//A

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

多态

动态编译：类型：可扩展性
即同一方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以只想对象的引用的类型有很多（父类，有关系的类）
多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用只想子类对象
注意：多态是方法的多态，属性没有多态性
instanceof （类型转换） ~ 引用类型，判断一个对象是什么类型

package com.baidu.oop;

import com.baidu.oop.demo06.Person;
import com.baidu.oop.demo06.Student;

public class Application {

    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new  Person();

        //可以指向的引用类型就不确定了，父类的引用指向子类的类型
        //Student能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();//父类的引用指向子类的类型
        Object s3 = new Student();

        //对象能执行那些方法，主要看对象左边的类型，和右边关系不大
        ((Student)s2).eat();//子类重写了父类的方法，执行了子类的方法
        //s1.eat();

    }


}

package com.baidu.oop.demo06;

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

package com.baidu.oop.demo06;

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

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

    1.static方法，属于类他不属于实例
    2.final常量
    3.privat方法
 */

package com.baidu.oop;

import com.baidu.oop.demo06.Person;
import com.baidu.oop.demo06.Student;
import com.baidu.oop.demo06.Teacher;

public class Application {

    public static void main(String[] args) {
        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        Object object = new Student();

        //System.out.println(X instanceof Y);//能不能编译通过

        System.out.println(object instanceof Student);//True
        System.out.println(object instanceof Person);//T
        System.out.println(object instanceof Object);//T
        System.out.println(object instanceof Teacher);//False
        System.out.println(object instanceof String);//F
        System.out.println("--------------------------------------------");
        Person person = new Student();

        System.out.println(person instanceof Student);//True
        System.out.println(person instanceof Person);//T
        System.out.println(person instanceof Object);//T
        System.out.println(person instanceof Teacher);//False
        //System.out.println(person instanceof String);//编译报错

        Student student = new Student();
        System.out.println("--------------------------------------------");
        System.out.println(student instanceof Student);//True
        System.out.println(student instanceof Person);//T
        System.out.println(student instanceof Object);//T
        //System.out.println(student instanceof Teacher);//编译出错
        //System.out.println(person instanceof String);//编译报错
    }


}

import com.baidu.oop.demo06.Person;
import com.baidu.oop.demo06.Student;

public class Application {

    public static void main(String[] args) {
        //类型之间的转化：父 子

        //高                   低
        Person obj = new Student();
        //Student将这个对象转换为Student类型，我们就可以使用Student类型的方法了
        Student student = (Student)obj;
        student.go();
        //((Student) obj).go();
    }

全站频道

大家都在搜索：

面向对象编程

面向过程&面向对象

什么是面向对象

回顾方法及加深

类和对象的关系

创建与初始化对象

封装

继承

多态