面向对象篇1以及方法的加深和回顾

最新推荐文章于 2024-11-03 11:01:20 发布

程序员就是阿欣

最新推荐文章于 2024-11-03 11:01:20 发布

阅读量93

点赞数

分类专栏：面向对象文章标签： java

本文链接：https://blog.csdn.net/weartheword/article/details/121647537

版权

面向对象专栏收录该内容

5 篇文章 0 订阅

订阅专栏

面向对象编程

java的给核心思想就是oop(面向对象编程)
oo指的是面向对象

面向过程 &面向对象

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

什么是面向对象

面向对象编程(Object-Oriented Programming OOP)
面向对象编程的本质就是：以类的方式组织代码，以对象的方式封装数据。
抽象
三大特征：封装、继承、多态
从认识论的角度考虑是现有对象后有类。对象：是具体的事物；类：是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板。

回顾方法和加深

方法的定义

修饰符

返回类型

package com.oop.demo01;

//Demo01就是一个类   用class修饰的  类里有一个核心的方法是main方法

public class Demo01 {
    //main 方法就是用来启动这个程序的；真正的程序里面只有一个main方法
    public static void main(String[] args) {

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

    public String sayHello(){
        return "hello,world";    //有返回值就return + 返回值类型
    }
    public void hello(){         //没有返回值类型的话就直接return就OK
        return;
    }
    public int max(int a,int b){
        return a>b ? a : b; //三元运算符
    }
}

break和return的区别
break：跳出switch，结束循环
return:方法结束；返回一个结果。
方法名：注意规范；见名知意
参数列表：参数类型参数名
异常抛出：？

方法的调用：递归

静态方法

package com.oop.demo01;

public class Demo02 {
    public static void main(String[] args) {
        //静态方法调用：类名.方法
        Student.say();
    }
}


package com.oop.demo01;
//学生类

public class Student {
    //方法
    //静态类
    public static  void say(){
        System.out.println("学生说话了");

    }

}

非静态方法

package com.oop.demo01;

public class Demo02 {
    public static void main(String[] args) {
        //非静态方法 如何调用这个类
        //实例化这个类  new
        //对象类型  对象名  =   对象值
        Student student = new Student();
        student.say();
    }
}


package com.oop.demo01;
//学生类

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

类调用的注意点

package com.oop.demo01;

public class Demo05 {
    //和类一起加载的
    public static void a(){
        b();                  //两个都是静态的方法a可以直接调用b
    }
    //类实例化之后才存在
    public static void b(){
        a();                        //b也可以调用a
    }
}




package com.oop.demo01;

public class Demo05 {
    //和类一起加载的
    public  void a(){                //两个是动态的也是可以直接调用
        b();
    }
    //类实例化之后才存在
    public  void b(){
        a();
    }
}


//注意：如果一个是静态一个是动态是无法调用的

形参和实参

 public  int add(int a,int b){

        return a+b;

    }   //形式参数



public class Demo03 {
    public static void main(String[] args) {
         int add = new Demo03().add(10, 20);  //new这个类(Demo03).方法(add)  然后输出
        System.out.println(add);
    }   //实参

值传递和引用传递

值传递

package com.oop.demo01;
public class Demo06 {
    //值传递
        public static void main(String[] args) {
        int i = 10;
        chance(i);
        System.out.println(i);
    }
    public static void chance(int x){
        x = 100;
    }
}
//结论：实参给形参传递数据的方式，直接将值复制一份给形参，实参和形参在内存上两个方法中相互独立的局部变量  不涉及到引用堆内存的数据 修改形参不会影响实参

引用传递

package com.oop.demo01;

public class Demo07 {
    public static void main(String[] args) {
        person person = new person();
        System.out.println(person.name); //null

        Demo07.changer(person);
        System.out.println(person.name);  //


    }
    //person是一个对象：指向的是--------------->person person = new person()；这是一个具体的人。可以改变。
    public static void  changer(person person){
        person.name = "黄黄黄";

    }
}
//定义一个person类,有一个属性 name
class person{
    String name;  //null
}