面向对像的概念和语法

面向对象

面向对象的概念

具体参考视频： 林粒粒的视频

如何创建一个类和怎么使用

简单理解类和对象

类：相当于一个模板，比如人类，人类可以有名字，可以吃饭，睡觉
对象：类进行实例化，例如一个人类名字为张三，年龄18，会吃饭等等

如何创建一个类

语法：

public class 类名{
  //成员变量
  //成员方法
}

例如：定义一个名字为Person的类

package com.xs.demo01;//类所在位置，（这个类所在的那个包里面）

/**
 * @Classname : Person
 * @Description : TODO 人类
 * @Author : lin_refuel@qq.com
 */
public class Person {
     //成员变量（属性）
    public String name;//姓名
    public int age; //年龄
    public String sex;//性别

    //成员方法（功能）
    public void eat(){
        System.out.println("人类的基本功能：吃饭");
    }
}

如何使用上面的类

new：通过关键字new,把类实例化

例子：

/**
 * @Classname : Persontest
 * @Description : TODO 测试类
 * @Author : lin_refuel@qq.com
 */
public class Persontest {
    public static void main(String[] args) {
        Person person = new Person();//把Person类进行实例化
        //对类里面的成员变量进行赋值,实例化的对象名字（person）.成员变量名字（name）
        person.name = "小肆";
        person.age = 17;
        person.sex = "boy";
        System.out.println(person.name + "," + person.age + "," + person.sex);
        //调用类里面的成员方法, 实例化对象名字（person）.成员方法（eat）
        person.eat();
    }
}

类里面的成员变量赋值和成员方法的使用，都在注释里面

运行结果：

成员变量和局部变量

成员变量：成员变量是在类以内的变量,类内都可以进行访问
局部变量：个人理解就是定义一个方法，方法内的变量就是局部变量

成员变量和局部变量名字冲突时，局部变量的优先级会更高，局部变量会屏蔽掉成员变量，但是不会修改成员变量的值

例子：定义了一个名字Person的类

package com.xs.demo01;//类所在位置，（这个类所在的那个包里面）
/**
 * @Classname : Person
 * @Description : TODO 人类
 * @Author : lin_refuel@qq.com
 */
public class Person {
     //定义成员变量age,赋值为18
    public int age = 18;
    //成员方法
    public void eat(){
        int a = 0; //定义一个局部变量a
        int age = 0;//定义一个局部变量age，和成员变量age名字相同
        System.out.println("局部变量age = " + age);
    }
    //成员方法
    public void sleep(){
       // System.out.println(a);
        System.out.println("成员变量age = " + age);
    }
}

不同包里面调用上面的Person类，需要进行导包

例如：
Person类在那个包里面

package com.xs.demo01;//Prson类在那个包里面

导包方式：
import com.xs.demo01包的位置，Person是包里具体要用到那个类的类名

import com.xs.demo01.Person;

package com.xs.demo02;
//使用其他包的类，导包
import com.xs.demo01.Person;
/**
 * @Classname : Persontest2
 * @Description : TODO 测试类，测试局部变量和成员变量
 * @Author : lin_refuel@qq.com
 */
public class Persontest2 {
    public static void main(String[] args) {
        Person person = new Person();
        //调用person里面的成员方法
        person.eat();
        person.sleep();
    }
}

局部变量作用域是方法内有效，方法外面无法进行访问

运行结果：

成员方法和静态方法

成员方法：个人理解为类内的方法就是成员方法

例如：

public void eat(){
System.out.prinln("吃饭");
}

静态方法：带有static修饰符的方法是静态方法，需要通过类名，进行调用，不能通过实例化对象进行调用

例如：

public static void sleep(){
System.out.println("睡觉");
}

代码：

两种方法具体调用方式

package com.xs.demo01;//类所在位置，（这个类所在的那个包里面）
/**
 * @Classname : Person
 * @Description : TODO 人类
 * @Author : lin_refuel@qq.com
 */
public class Person {
   //定义了一个成员方法eat
    public void eat(){
        System.out.println("我是一个成员方法，可以通过实例化的对象名字进行调用");
    }
    //定义了一个静态方法，名字为sleep
    public static void sleep(){
        System.out.println("我是一个静态方法，通过类名.方法名进行调用");
    }
}

调用上面的类

/**
 * @Classname : Persontest
 * @Description : TODO 测试类
 * @Author : lin_refuel@qq.com
 */
public class Persontest {
    public static void main(String[] args) {
        //实例化对象
        Person p = new Person();//实例化对象，名字为p
        //调用成员方法
        p.eat();
        System.out.println("==================");
        //调用静态方法
        Person.sleep();
    }
}

运行结果：

对象之间的赋值

简单理解：对象之间的赋值就像是给当前对象重新起了一个名字，两个名字代表的是一个空间，都可以使用里面的成员变量和方法

例子： 有个人名字叫张三，工资3000，年龄22，但是有一天他入赘后改了个名字李四，李四和张三都是一个人，别人问李四，你工资多少，今年多大，李四回答：工资3000，22岁

代码：

定义了一个名字为 A的类

package com.xs.demo02;

/**
 * @Classname : A
 * @Description : TODO A类
 * @Author : lin_refuel@qq.com
 */
public class A {
    //定义两个成员变量
    public int data = 10;
    public int data2 = 20;
}

调用上面的A类

/**
 * @Classname : B
 * @Description : TODO B类 - 测试类
 * @Author : lin_refuel@qq.com
 */
public class B {
    public static void main(String[] args) {
            //对象之间的赋值
        A a = new A();//实例化对象A，名字为a
        System.out.println(a.data);
        System.out.println(a.data2);
        System.out.println("=================");
        A b = a;//实例化的对象名字起一个别的名字，名字为b
        b.data = 100;
        b.data2 = 200;
        //通过另一个名字b输出A类里面的data和data2
        System.out.println(b.data);
        System.out.println(b.data2);
        System.out.println("===================");
        //再次通过a访问A类里面的data和data2
        System.out.println(a.data);
        System.out.println(a.data2);
    }
}

运行结果：

方法中对象的使用

对象作为方法的实际参数进行传递

定义一个Person类

/**
 * @Classname : Person
 * @Description : TODO 人类
 * @Author : lin_refuel@qq.com
 */
public class Person {
    //人类的两个属性
    public String name;//姓名
    public int age;//年龄

    //人类的基本功能
    public void eat(){
        System.out.println(name + age +"会吃");
    }
}

调用上面的Person类

/**
 * @Classname : test
 * @Description : TODO - 测试类
 * @Author : lin_refuel@qq.com
 */
public class test {
    public static void main(String[] args) {
        //实例化对象
        Person p = new Person();
        p.name = "小肆";
        p.age = 17;
        p.eat();
        System.out.println("=======================");
        //把对象p作为show方法的实际参数的进行传递
        show(p);
        //调用Person里面的eat方法
        p.eat();
    }

    /**
     * 输出 Person 类里面的信息
     * @param person 对象p的形式参数
     */
    public static void show(Person person){
        //修改Person里面的成员属性的值
        person.name = "张三";
        person.age = 20;
    }
}

1. 把对象p作为方法show的实际参数进行传递，方法show的形参和对象p代表的是一个空间
2. 对象作为实参传递的传递的是对象名字，形式参数的写法是 类名 和 重新命名的对象名字，具体参考show方法的形式参数

运行结果：

对象作为方法的返回值

简单理解：在方法里面实例化一个对象，作为返回值进行返回

例子：

定义一个名字为人类的对象

/**
 * @Classname : Person
 * @Description : TODO 人类
 * @Author : lin_refuel@qq.com
 */
public class Person {
    //定义两个成员属性
    public String name; //姓名
    public int age; // 年龄

    /**
     *一个成员方法
     * 输出xx会吃
     */
    public void eat(){
        System.out.println(age + "岁的" + name + "会吃");
    }
}

调用上面的类

/**
 * @Classname : test
 * @Description : TODO 对象作为返回值
 * @Author : lin_refuel@qq.com
 */
public class test {
    public static void main(String[] args) {
        /**
         * 定义一个可以返回一个Person类对像的方法，名字为 getperson
         * 定义一个Person类的对象，名字为person接受方法getperson的返回值
         */
        Person person = getperson("小肆",17);
        //通过person调用方法eat
        person.eat();
    }

    /**
     * 返回一个Person类的对象的方法
     * @param name 姓名
     * @param age 年龄
     * @return Person类对象
     */
    private static Person getperson(String name, int age) {
        Person person = new Person();
        person.name = name;
        person.age = age;
        return person;
    }
}

方法作为返回值，需要同类型的方法进行接受，过程相当于是给对象之间赋值的过程，给对象重新起名

运行结果：

this关键字的用法

this 一般用于外部传入的参数或当前方法的局部变量，与类中成员变量名冲突时，解决冲突问题。成员方法同变量。

通过 this. 的方式调用的内容都是当前类的成员（属性或方法）

• 用法： this.成员变量名 或 this.成员方法名()

定义一个名字为Person类

/**
 * @Classname : Person
 * @Description : TODO 人类
 * @Author : lin_refuel@qq.com
 */
public class Person {
    //定义两个成员属性
    public String name; //姓名
    public int age; // 年龄

    /**
     * 输出xx会吃
     */
    public void eat(){
        System.out.println(age + "岁的" + name + "会吃");
    }

    /**
     * 调用Person类中的eat方法
     */
    public void showeat(){
        this.eat();
    }

    /**
     * 输出成员变量和局部变量的值
     */
    public void show(String name,int age){
//        System.out.println("局部变量name = " + name);
//        System.out.println("局部变量 age" + age);
//        System.out.println("==================");
//        System.out.println("this.name = " + this.name);
//        System.out.println("this.age = " + this.age);
        /**
         * 通过形参给类中成员方法进行赋值
         */
        this.name = name;
        this.age = age;
        System.out.println("this.name = " + this.name);
        System.out.println("this.age = " + this.age);
    }
}

调用上面类

/**
 * @Classname : test2
 * @Description : TODO 测试类 this的用法
 * @Author : lin_refuel@qq.com
 */
public class test2 {
    public static void main(String[] args) {
        Person person = new Person();
        /**对Person类里面的成语变量进行赋值
         * person.name = "小三";
         * person.age = 20;
         **/
        //调用Person类里面的show方法,传递两个实参
        person.show("小肆",18);
        //调用Person类中showeat方法
        person.showeat();
    }
}

两个运行结果：

1. 注释掉代码打开的运行结果：this.修饰的变量和方法是类中的成员变量和方法，当局部变量和成员变量名字冲突时候，带有this.修饰词不会被覆盖
   
   2.this.关键字，一般用于形式参数给类中成员变量进行赋值
   运行结果：