java入门到精通（五）面向对象

前面的内容：
java入门到精通（一）语言基础
Java入门到精通（二）流程控制
Java入门到精通（三）数组介绍
Java入门到精通（四）字符串

1.面向对象概述

面向对象程序设计（OOP），面向对象思想是人类最自然的一种思考方式，它将预处理的问题都进行了抽象，同时要了解对象拥有的属性以及行为。面向对象的实质是对现实世界的对象进行了建模。
（1）对象

• 万物都可为对象，有生命和没有生命的都可抽象为对象。

• 程序是对象的集合，他们通过发送消息来告诉彼此要做的事情。

• 每个对象都有其类型，也就是他们的当前类类型。

• 某个特定类型的所有对象都可以接受所有的消息。

  通常将对象分为静态的和动态两种。
  静态：比如一只鸟它具有一双翅膀、两只爪（属于它自身的属性）
  动态：鸟会叫、会吃东西、会飞翔（属于它自身的行为）
  一般情况下静态的都是变量、动态的是方法。
  

类就是封装行为与属性的载体（也可以说具有相同属性和行为的一类实体叫类），而对象就是类抽象出来的。	

（2）面向对象的特点：

• 封装性
• 继承性
• 多态性
  （3）类与对象
  成员变量（属性）的定义

class crow{
    public String wing;//翅膀  这里的权限修饰符可不加
    String claw;//爪子
    String feather;//羽毛
}

成员方法（行为）的定义

public void fly(){
        System.out.println("乌鸦可以飞");
    }
private String cry(){
    System.out.println("乌鸦可以叫");
    return null;
	}
public void information(String wing){
        System.out.println("乌鸦有一双"+wing);
    }
public void crowSize(int[] size){
        System.out.println("第一只乌鸦大小"+size[0]);
    }    

对象的创建

class crow{
    String claw;//爪子

    public crow(String claw) {
        this.claw = claw;
    }
}
public class tries {

    public int changeNumber(int i){
        return ++i;
    }

    public void changeArr(int[] arr ){
        arr[0] = 250;
    }
		//对象的创建
        tries tries = new tries();
        crow crow = new crow("dsa");
    

引用存放的是一个类对象的地址，并不是一个对象。
不同的对象对类可见的信息是一样的，但是一个对象对类中的数据出改变，其他对象可见的数据不变。

在定义某个成员方法的时候，如果不加权限修饰符，方法的权限会默认。

这里需要注意一个问题：

public class tries {

    public int changeNumber(int i){
        return ++i;
    }

    public void changeArr(int[] arr ){
        arr[0] = 250;
    }

    public static void main(String[] args) {
        tries tries = new tries();
        int i = 0;
        int[] arr = new int[]{1,2,3};
        tries.changeNumber(i);
        System.out.println(i);
        tries.changeArr(arr);
        System.out.println(Arrays.toString(arr));
    }
}

上述的代码中可以注意在成员方法中对i的值加一操作，但是最后i的值并没有发生改变。而数组中的值被改变了

原因：

1. 函数调用中发生的数据传送是单向的。 即只能把实参的值传送给形参，而不能把形参的值反向地传送给实参。
   因此在函数调用过程中，形参的值发生改变，而实参中的值不会变化。
2. 当形参和实参不是指针类型时，在该函数运行时，形参和实参是不同的变量，他们在内存中位于不同的位置，形参将实参的内容复制一份，在该函数运行结束的时候形参被释放，而实参内容不会改变。
   
3. 当形参为引用变量时，在调用该函数的过程中，传给函数的是实参的地址，在函数体内部使用的也是实参的地址，即使用的就是实参本身。所以在函数体内部可以改变实参的值。

（4）、构造方法
类除了有成员方法以外还有构造方法，构造方法与类名重名，对象的创建就是通过构造方法完成的。每当类实例化一个对象时，类会自动调用构造方法。

• 构造方法没有返回类型，也不能定义为void。

• 构造方法的名称要与类名的名称相同。

• 构造方法的主要作用是完成对象的初始化工作。

  这里需要注意当类中没有创建构造方法时，编译器会自动的为类创建一个无参构造函数。
  

2.this、super关键词

this关键词作为对象的两种用法

• 构造器中引用该构造器正在初始化的对象。
• 在方法中引用调用该方法的对象。

//构造器中引用该构造器正在初始化的对象
class people{
    public int age;
    
	public people(int age){
        this.age = age;
    }
    
    public people(){
    	//对年龄进行初始化
        this(1);//这里需要注意的是this语句之前不能有其他的语句否则会编译器直接报错
    }
    
    public people grow() {
        age ++;
        return this;//返回的是people引用
    }
    
    public void try_1(){
        System.out.println("try_1");
    }
    
    public void try_2(){
    	System.out.println(this.age);//当前对象调用类的属性
        System.out.println("try_2");
        this.try_1();//在方法中引用调用该方法的当前对象
 		//其实就相当于people p = new people()原理是相同的  但是这样写就不是同一个对象
    }
    
    public static void main(String[] args) {
        people p = new people();
        p.gorw();
        p.try_2();
        //可以连续调用同一个方法
        p.grow().grow();
        System.out.println("p对象的age的值是："+p.age);
    }
}

super关键词
继承(extends)下一篇的文章会详细讲

class animal{
    String color = "white";
    int number;
    public animal(int number){
        this.number = number;
    }
    public void eat(){
        System.out.println("父类eat方法");
    }
    public void pMethon(){
        System.out.println("父类方法");
    }
}
class pig extends animal{
    public pig(){
        super(10);//调用父类具有int类型的构造函数 
    }
    @Override
    public void eat() {
        super.pMethon();//访问父类方法
        System.out.println("子类eat方法");
        System.out.println(super.color);//访问父类的属性
        pMethon();
    }
    public void pMethon(){
        System.out.println("子类方法");
        System.out.println(number);//打印值为10
    }
}

这里面向对象的内容还没有完，下一篇文章会介绍接口interface，继承extends，static关键词等。

不对的内容麻烦大佬纠正、补充谢谢~
希望大家可以点个赞