Java基础之（十三）：类与对象

初识面向对象

面向对象 & 面向过程

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

什么是面向对象

面向对象编程（Object-Oriented Programming, OOP）
面向对象编程的本质就是：**以类的方式组织代码，以对象的形式组织（封装）数据。
抽象
三大特性：
- 封装：把数据进行包装起来，留一个接口（将属性私有化并提供公共的访问接口）
- 继承：A类继承B类，A类就有了B类的所有特征
- 多态：同一事物在不同属性下有着不同的表现结果
从认识论的角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板。

方法回顾和加深

方法的定义

修饰符
返回类型

格式：

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

//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;//三元运算符！
}

break：跳出switch，结束循环和 return 的区别
方法名：注意规范见名知意
参数列表：（参数类型，参数名）...
异常抛出

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

方法的调用：递归

静态方法

先定义一个Student类

public class Student {}

//静态方法
public static void say(){
    System.out.println("学生");
}

非静态方法

//非静态方法
public void sing(){
    System.out.println("教师");
}

然后使用别的类来调用

public class Demo02 {
    public static void main(String[] args) {
        //静态方法  static
        Student.say();

        //非静态方法
        //第一种方法：实例化这个类 new
        new Student().sing();

        //第二种方法：
        //对象类型  对象名  =   对象值;
        Student student = new Student();
        student.sing();


    }


    //静态方法只能调用静态方法，非静态方法可以调用静态方法
    //和类一起加载的
    public static void a(){
       // b();
    }

    //类实例化之后才存在
    public void b(){

    }
}

形参和实参

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

    Demo03 demo03 = new Demo03();
    int sum2 = Demo03.add2(2,3);
    System.out.println(sum2);
}


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

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

值传递和引用传递

值传递：

//值传递
public class Demo04 {

    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);

        Demo04.change(a);

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

    //返回值为空
    public static void change(int a){
        a=10;
    }

}

引用传递

//引用传递: 对象，本质还是值传递
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);//lei
    }

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


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

this关键字: 表示当前的类或者对象

对象的创建分析

类与对象的关系

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

创建与初始化对象

使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

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);

}

//学生类
public class Student {
    //属性：字段
    String name;
    int age;

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


    }

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点：
- 1. 必须和类的名字相同
- 1. 必须没有返回类型，也不能写void

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

String name;
int age;

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

public Person() {
}


//有参构造: 一旦定义了有参构造，无参构造必须显示定义
public Person(String name) {
    this.name = name;
}

//alt + insert
public Person(String name, int age) {
    this.name = name;
    this.age = age;
}
/*
    构造器：
    	1. 和类名相同
    	2. 没有返回值
    作用：
        1. new  本质在调用构造方法
        2. 初始化对象的值
    注意点：
        1. 定义有参构造之后，如果想要使用无参构造，显示的定义一个无参的构造。
        
        Alt + Insert
        this. = 
*/

public static void main(String[] args) {

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

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

    }

创建对象内存分析

import com.oop.demo03.Pet;

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);

        
    }
}

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

    //无参构造
    public void shout(){
        System.out.println("叫了一声");
    }
}

简单小结类与对象

类与对象

类是一个模板，对象是一个具体的实例
方法

定义、调用！
对象的引用

引用类型：基本类型（8）

对象是通过引用来操作的：栈--->堆
属性：字段Field 成员变量
- 默认初始化：
  - 数字： 0 0.0
  - char : u0000
  - boolean: false
  - 引用：null
- 修饰符属性类型属性名 = 属性值！
对象的创建和使用
- 必须使用new关键字创造对象，构造器 Person student = new Person();
- 对象的属性 student.name
- 对象的方法 student.sleep()
类：

静态的属性属性

动态的方法方法

posted @ 2021-02-25 18:07 lyl-star 阅读(93) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

lyl-star

Java基础之（十三）：类与对象

初识面向对象

面向对象 & 面向过程

什么是面向对象

方法回顾和加深

对象的创建分析

类与对象的关系

创建与初始化对象

创建对象内存分析

简单小结类与对象

公告