面向对象编程-1

什么是面向对象

面向过程：步骤清晰简单【适合处理一些较为简单的问题】

面向对象：分类的思维模式，思考解决问题需要哪些分类，然后单独进行思考，最后对某个分类下的细节进行面向过程的思索。【适合处理复杂的、需要多人协作的问题】

对于复杂的问题，宏观上用面向对象把我，微观上采用面向过程的思想

OOP （面向对象编程）：Object-Oriented-Progarmming

OOP的本质：以类的方式组织代码，以对象的形式封装数据

抽象：把对象的共同点抽取出来

Java三大特性：

封装：把数据给封装起来

继承：子类继承父类

多态

方法的回顾与加深

方法的定义

修饰符：public

返回值类型：int、String ...

break:跳出switch,结束循环

return：结束方法

方法名：参考驼峰原则，见名知意

异常抛出：throws IOException ...

具体见方法详解

方法的调用

1 静态方法与非静态方法

静态方法

public class Student {
/*
@author xiuga
@version 1.8
@since 2021-02-17 16:36
*/
    public static void say(){
        System.out.println("hello");
    }
}

public class Demo01 {
/*
@author xiuga
@version 1.8
@since 2021-02-17 16:35
*/
public static void main(String[] args) {
    //静态方法调用 类.方法名
    Student.say();
}
}

非静态方法

public class Student {
/*
@author xiuga
@version 1.8
@since 2021-02-17 16:36
*/
    public  void say(){
        System.out.println("hello");
    }
}

public class Demo01 {
/*
@author xiuga
@version 1.8
@since 2021-02-17 16:35
*/
public static void main(String[] args) {
    //非静态方法调用  实例化这个类 new
    //对象类型 对象名 =对象值；
    Student student = new Student();
    student.say();
}
}

注意！

//a方法为静态方法，b方法为非静态方法时，a方法不能调用b方法
//a和类一起加载
public  static void a(){
    b();
}
//b实例化后才出现
public void b(){
}

2 值传递与引用传递

值传递

package com.oop.demo01;
?
public class Demo02 {
/*
@author xiuga
@version 1.8
@since 2021-02-17 17:08
*/
    //值传递
public static void main(String[] args) {
    int a=1;
    System.out.println(a);
    Demo02.change(a);
    System.out.println(a);
}
    //把change方法中的a改成b也一样，当a=10,change方法已经调用完毕
public static void change(int a){
    a=10;//并不会赋值给任何人
}
}

引用传递

package com.oop.demo01;
?
public class Demo03 {
/*
@author xiuga
@version 1.8
@since 2021-02-17 17:22
*/
    //引用传递 对象 本质还是值传递
    //change（）和main()指向同一个内存空间，值会一起改变
public static void main(String[] args) {
    Person person = new Person();
    System.out.println(person.name);
    change(person);
    System.out.println(person.name);
}
    public static void change(Person person){
    //person是一个对象
        person.name="Xiuga";
    }
}
class Person{
    String name;
}

具体他们的区别可见方法详解，上次看得似懂非懂，这次懂七八成了。

对象的创建分析

类与对象的创建

类是一种抽象的数据类型。对象是抽象概念的具体实例。

使用new关键字创建对象

public class Student {
/*
@author xiuga
@version 1.8
@since 2021-02-17 22:43
*/
    //属性
    String name;
    int age;
    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}

package com.oop.demo02;
?
//一个项目应只有一个main方法
public class Application {
/*
@author xiuga
@version 1.8
@since 2021-02-17 22:43
*/
public static void main(String[] args) {
    /*类：抽象的 需要实例化
    类实例化后会返回一个自己的对象
    如xm就是Student类的出一个对象
    * */
    Student xm = new Student();
    Student xh = new Student();
    //以对象的形式封装数据
    xm.name="小明";
    xm.age=1;
    System.out.println(xm.name);
    System.out.println(xm.age);
    xh.name="小红";
    xh.age=1;
    System.out.println(xh.name);
    System.out.println(xh.age);
}
}

构造器详解

构造器又名构造方法，是在进行创建对象的时候必须调用的

特点：1 必须和类的名字相同。 2 必须没有返回类型，也不能写void

//构造器
    public Person(){
        
    }

注意：当Person类中相使用有参构造器，必须写上无参的构造器

如

package com.oop.demo02;
?
public class Person {
String name;
//构造器的作用
    //1.使用new关键字，本质是在调用构造器
    //2.用来初始化值
public Person(){
?
}
public Person(String name){
    this.name=name;
}
}

package com.oop.demo02;
?
//一个项目应只有一个main方法
public class Application {
public static void main(String[] args) {
    //new的对象调用构造器，无参调用无参构造器，有参调用有参构造器
    Person person=new Person("X");
    System.out.println(person.name);
}
}

类与对象小结

1.类与对象

类是一个模板，抽象的；对象是一个具体的实例

2.方法

方法的定义以及调用

3.对象的引用

引用类型：8中基本类型-byte int short double long float boolean long

对象是通过引用来操作的

4.属性：字段 field 成员变量

5.对象的创建和使用

必须使用new关键字创建对象，构造器 Student Xiuga=new Student

对象的属性 student.name

对象的方法 student.shout()

6.类

静态的属性 属性

动态的行为 方法

面向对象编程-1

原文：https://www.cnblogs.com/xiugablog/p/14440419.html