面向对象

1.思想

2.面向过程和面向对象的区别

面向过程：

今天早上要去上课的完整过程：起床---刷牙---洗脸---穿鞋---出门--打车--走进教室---上课

特点：具体的每一步我们都是参与者，关注的是解决问题的过程

面向对象：

洗衣服：直接将衣服扔进洗衣机里，然后晾衣服。中间没有关注洗衣机洗衣服的过程。

特点：只关注最终的结果

3.面向对象的特点：

A.更符合人们思考问题的方式

B.将我们从执行者变为了调用者

C.将问题简化

4.举例：把大象装入冰箱

设计为更符合面向对象思想的思考：

分析： 1.有哪些类（具有相同属性特征和相似行为归并在一起称为类，看不见摸不着）

大象 冰箱 oopDemo（面向对象）

2.每个类中都有哪些行为、动作（方法）

大象类：吃草 走路

冰箱类：开门、关门

OOPDemo：装大象的方法、程序入口 main方法

3.类与类之间又怎样的关系

5.把大象装入冰箱实现过程

package org.wdit.OOp;

public class ElephantDemo {
    public static void eat() {
        System.out.println("吃草");

    }
      public static void walk(){
           System.out.println("走路");
      }
}




package org.wdit.OOp;

public class IceDemo {
    public static void opendoor() {
        System.out.println("打开冰箱门");

    }
    public static void closedoor() {
        System.out.println("关闭冰箱门");

    }

}





package org.wdit.OOp;

public class OOPDemo {
    public static void putin(ElephantDemo elephant) {
        System.out.println("装大象");

    }

    public static void main(String[] args) {
        //如何使用面向对象过程思想解决此问题
        System.out.println("打开冰箱门");
        System.out.println("装大象");
        System.out.println("关闭冰箱门");


        System.out.println("----------------");
        //使用面向对象解决此问题
        //调用冰箱开门行为
        IceDemo.opendoor();
        //装入大象
        putin(new ElephantDemo());
        //调用关闭冰箱门的行为
        IceDemo.closedoor();

    }
}

6.面向对象开发设计与特征

开发：

不断的创建对象、使用对象、修改对象

设计：

管理和维护对象之间的关系。一个好的对象设计，可以实现程序的简化并且易于维护

特征：

封装、继承、多态

7.类和对象

类：

具有相同属性特征和行为动作的一类事物，统称为类，看不见摸不着，只是一个抽象的概念。

对象：

万事万物皆对象，能看得见摸得着的东西是对象。

类和对象的关系：

对象是类具体的描述，类是对象的抽象。

举例：学生：

属性：姓名、年龄、性别、体重、身高.......

行为：走路、吃饭、说话、学习....

属性：就是描述该事务的信息

行为:该事务能干什么

注：java中最基本的单位是： 类。所以我们尝试使用类来描述事物。

事务 类

属性 成员变量

行为 成员方法

例如： 学生 类

姓名等为 成员变量

走路等为 成员方法

8.类的使用

定义：

访问修饰符 class类名 {

成员变量

构造方法（无参、有参），默认存在一个隐形的无参构造方法

成员方法

}

类的调用：

1.实例化 语法：类名 对象名 =new 类名（）；比如：学生类 Tom=new 学生类（）；无参构造

类名 对象名 =new 类名（[实参列表]）；有参构造

2 .调用类中的属性：对象名.属性名 比如：Tom.name

3.调用类中的方法：对象名.方法名（[实参列表]）；

构造方法：

用来实例化类的对象的方法成为构造法

分为： 有参构造方法：实例化对象的同时为类中的成员属性进行赋值

无参构造方法：实例化对象的同时为类中的成员属性不进行赋值

语法格式：访问修饰符 方法名（）{//默认的隐形无参构造方法

}

 

访问修饰符 方法名（[形参列表]）{//有参构造法

this.成员属性=形参；

...............

}

注意：

1.构造方法名必须和其类名同名，

2.没有返回值这一说法，

3.如果在一个类中显示的定义了有参构造方法，则隐形无参构造将不存在，此时建议将无参构造方法显示定义

4.每个类都有构造方法，如果没有显示地为类定义构造方法，java编译器将会为该类提供一个默认隐形无参构造方法

5.创建一个类的对象时，至少需要调用一个构造方法

6.一个类中可以有很多个构造方法，他们之间构成了方法重载，即构造方法重载

this：

代表当前类的对象

注意：此条调用构造方法语句必须是方法体中的第一行语句

用途：

1.用于区分成员变量和局部变量同名冲突问题

//类的定义及应用
public class Student {
    //成员变量
    String name;//null
    int age;//0
    String email;//null
    String address;//null

    //定义有参构造方法
    public Student(String name, int age, String email, String address) {
        this.name = name;
        this.age = age;
        this.email = email;
        this.address = address;
    }

2.可以调用当前类的构造方法。语法：this（[参数列表]）；不传参数在调用当前类的无参构造方法，相反调用参数列表相吻合的有参构造方法

3.可以调用成员属性：this.成员属性

4.可以调用成员方法：this.成员方法

package org.wdit.OOp;
//this关键字的应用
//1.调用当前类的属性(区分成员变量和局部变量同名赋值问题）
//2.调用当前类的方法
//3.调用当前类的其他构造方法
/*
注意：this关键字访问类的成员变量和成员方法不受权限控制
*    可以访问本类中所有的成员变量和成员方法，包括Private的成员变量和成员方法
* */
public class Person {
    String name;
    int age;

  /*  public Person() {
        this("tom");
    }
    public Person(String name) {
             this(20);
    }
    //以上代码构成了死归问题，就是构造方法之间的调用没有退出条件*/


    public Person() {

    }
    public Person(String name) {
        this.name=name;

    }

    public Person(String name,int age) {
        this(name);//此行代码是为了更好的演示this调用构造方法时必须为首行代码的举例
        this.age=age;
       // this(name);//此条调用方法构造语句必须是方法体中的第一行语句
    }



    public void setName(String name){
        this.name=name;
    }
    public void testMethod(String name){
        this.setName(name);//通过this调用了当前类的其他方法
        System.out.println(this.name);
    }

    public static void main(String[] args) {
        Person person=new Person();

        System.out.println("------------------this调用本类属性---------------");
        person.setName("tom");
        System.out.println("name1"+person.name);

        System.out.println("------------------this调用本类方法---------------");
        person.testMethod("lili");

        System.out.println("------------------this调用本类构造方法---------------");
            Person person1=new Person("tom",30);
        System.out.println(person1.name);
        System.out.println(person1.age);

    }




}

类的应用：

package org.wdit.OOp;
//类的定义及应用
public class Student {
    //成员变量
    String name;//null
    int age;//0
    String email;//null
    String address;//null

    //显示定义无参构造方法
    public Student() {
    }

    //定义有参构造方法
    public Student(String name, int age, String email, String address) {
        this.name = name;
        this.age = age;
        this.email = email;
        this.address = address;
    }


    //成员方法
    //获取姓名
    public String getName() {
        return name;
    }

    //设置姓名
    public void setName(String name) {
        this.name = name;
    }

    //设置并获取年龄
    public int getAge(int age) {
        if (age > 0 && age < 16) {
            this.age = 16;
        } else {
            this.age = age;
        }
        return this.age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                ", address='" + address + '\'' +
                '}';
    }//to string 重写
}

package org.wdit.OOp;
//学生类的测试类
//需求：调用student类中的成员属性和成员方法
public class StudentTest {
    public static void main(String[] args) {
        //1.实例化Student类的对象
        Student zhangsan=new Student();
                                     //2.调用属性  对象名.属性名并赋值
        zhangsan.name = "zhangsan";
        zhangsan.age = 20;
        zhangsan.email = "zhangsan@163.com";
        zhangsan.address = "西安";
        //3.调用属性并输出
       System.out.println("姓名："+zhangsan.name);
        System.out.println("年龄："+zhangsan.age);
        System.out.println("邮箱："+zhangsan.email);
        System.out.println("address："+zhangsan.address);
        System.out.println("----------------------------------------------");




        //4.思考如果student类中有100个属性，难道也通过上述方式进行赋值吗？
        //分析：可以通过有参构造方法一次性进行属性赋值

        Student tom = new Student("tom",20,"tom@163.com","西安");
        System.out.println("姓名："+tom.name);
        System.out.println("年龄："+tom.age);
        System.out.println("邮箱："+tom.email);
        System.out.println("address："+tom.address);

        System.out.println("---------------------------------");
                                           //调用成员方法 对象名.方法名
        int stuAge = tom.getAge(25);//赋值方法调用有返回值有参数列表方法
        System.out.println("stuAge:"+stuAge);
        System.out.println("姓名:"+tom.getName());
        
        tom.setName("lily");//调用无返回值方法
        System.out.println("name=:"+tom.getName());//通过输出方式调用有返回值无参数方法
    }
}

9.在一个类中可以有以下变量

类变量：

存在于类中方法之外，声明时必须加static关键字：static int flag；随着类的加载而产生

局部变量和成员变量区别：

1.声明的位置不同:

成员变量（实例变量）：类中，方法体外

局部变量：方法体中或方法声明上

2.内存中存储的位置不同

成员变量位于堆内存中

局部变量在栈内存中

3.生命周期不同

成员变量随着对象的产生而产生，随着对象的消亡而消亡

局部变量随着方法的调用而产生，随着方法调用完毕而结束

4.初始状态不同

成员变量：有默认的初始化值

局部变量：没有默认的初始值，必须手动初始化后，才能使用

5.执行优先级

当成员变量和局部变量同名时，调用采用”就近原则“。