面向对象编程思想

05面向对象编程思想

一、OOP

1、oop

面向对象编程

2、oop是Java语言编程思想

这种思想指导我们程序员如何使用Java写代码。

3、面向对象和面向过程区别

面象过程:强调的是解决问题的步骤,直接写函数即可,直接调用函数:函数名(..)。

面向对象:强调使用对象解决问题,对象是属性和方法的综合体,使用对象名.属性名和对象名.方法名(..)。

 

4、oop编程

倒推:

使用对象解决问题;

需要对象;

创建一个对象;

对象是什么样的呢?

我们需要告诉计算机,对象是什么样的,有哪些功能。

提供模板:类。

类:创建对象的模板。

对象:是类的具体化。

对象是一个独立的个体。

 

根据问题,进行分析;

通过分析,定义模板(抽象成类);

通过类,创建对象(实例化,实例=对象);

使用对象的属性和方法,解决问题。

5、oop应用

问题:

老于是一个胖子,体重200公斤。为了女朋友决定减肥,通过不懈的努力,体重将为100公斤。

分析,抽象成类:

人类{

属性:姓名,体重

方法:减肥(体重由200变成100)

}

通过类,创建对象:

类名 对象名=new 类名();

通过对象,解决问题:

对象名.属性名 保存数据

对象名.方法名(..) 解决问题的过程

二、类的定义

1、语法:

[修饰符] class 类名{

//定义属性:成员变量

//初始值:常量,所有对象值相同

[修饰符] 数据类型 属性名[=初始值];

//赋值语句错误:属性名=初始值

//初始化语句,必须写到方法体内或初始化块中。

//定义方法:成员方法

[修饰符] 返回值类型 方法名([参数]){

//方法体:解决问题的过程

}

//定义构造器

[修饰符] 类名([参数]){

//方法体:属性初始化

}

}

public class Person {
   //属性:成员变量
   public  String  name;
   public  double  weight;


   //方法:成员方法
   public   void  loseWeight(){
       System.out.println("原始体重:"+weight);
       weight=100;
       System.out.println("减肥后的体重:"+weight);
  }

}

三、创建对象

创建对象,其实就是在堆里开辟一个大空间。

里面包含属性和方法。

这些属性和方法,是参考类赋予的。

1、语法:

类名 对象名=new 类名();

int[] 数组名=new int[4];

//主方法:程序执行的入口
  public static void main(String[] args) {
//       使用类名声明一个变量,表示改变量存储的是该类型的对象的首地址(堆)。
//       new Person();
//       在堆里开辟空间
//       以类作为模板,赋予对象属性和方法
//       返回对象在堆里的首地址
//       将地址赋给p1
      Person   p1=new Person();

      Person   p2=new Person();



  }

每new一次,都会产生一个新对象,在堆内存中存储。

 

2、原理

jvm先加载类的信息到内存的方法区中。

在堆内存中开发空间,保存对象的信息。

然后以类为模板创建对象,类中有哪些属性和方法,就会给对象添加那些属性和方法。

 

 

四、使用对象

1、语法:

对象名.属性名

对象名.方法名(..)

        p.name="老于";
      p.weight=200;

      p.jianfei();

      p2.name="老王";
      p2.weight=300;

      p2.jianfei();

2、原理

p.jianfei();

通过p中保存的首地址,找到对应的堆内存中的对象。

然后,找到该对象中的属性和方法;

最后执行属性和方法体。

 

五、基本类型和引用类型

1、基本数据类型

基本类型的变量存储是单一值。

2、引用数据类型

引用类型的变量中存储的是对象的首地址。

数组:数组对象内部分为若干元素,每个元素可以存储一条数据。

数组名.length,length并不是属性,length是计数器中记录数组的长度。

类:类类型的对象内部分为属性和方法。

接口:在类类型的基础上,会向上转型。

六、变量

1、变量

Java中用于存储数据的容器。

变量的特点:存储的数据是可以变化(修改)。

2、变量的分类

Java语言中,变量分为局部变量和成员变量(对象的属性)。

局部变量:声明在方法体内的变量。不属于任何对象。

成员变量:声明在类中,方法体外的变量。是对象的属性。

3、局部变量和成员变量的区别

(1)声明的位置

局部变量:声明在方法体内的变量。

成员变量:声明在类中,方法体外的变量。

(2)作用范围

局部变量:只能用于声明它的方法体内,其他方法体无法访问。

成员变量:可以作用于当前类的所有方法体内。

(3)缺省值

成员变量:有缺省值。

byte short int long 0

float double 0.0

char 空白字符

boolean false

引用类型 null

局部变量:没有缺省值。

null的含义:null是一种引用类型的数据,表示没有对象的地址!!!

(4)修饰符

成员变量:可以使用任何修饰符修饰。(public protected private 不写) static final ==

局部变量:只能使用final。

(5)重名问题

局部变量(或参数)之间如果作用范围有交集,不能重名;

成员变量之间如果作用范围有交集,不能重名;

成员变量和局部变量(或参数)是可以重名的!!

public class Person2 {
   public   String  a;
   public   double  b;
   public   int     c;
   public    char   d;
   public    boolean   e;

   public static void main(String[] args) {
       Person2   pp=new Person2();
       System.out.println(pp.a);
       System.out.println(pp.b);
       System.out.println(pp.c);
       System.out.println(pp.d);
       System.out.println(pp.e);

       final int  f=10;
  }
}

七、方法参数

1、语法

[修饰符] 返回值类型 方法名([参数]){

//方法体:解决问题的过程

}

2、方法的作用和调用

(1)作用

所谓方法,就是一个有名字的语句组。

方法体,解决问题的过程。

(2)调用

我们可以通过对象名.方法名(..)调用某个方法。

调用方法,就是执行方法体中的代码。执行完毕,方法的调用语句结束。

3、方法的参数

(1)作用

可以根据用户的需要,每次调用方法时,都可以向方法体内传入变化的数据。

(2)参数定义

参数定义在方法名后小括号中。

一个方法,可以定义0到多个参数。

每一个参数:【final】 数据类型 参数名 , 多个参数中间使用逗号分隔。

(3)传参

方法调用时,在小括号中给对应的参数赋值。不能使用=号符号。

调用一个方法时,方法有参数,有几个参数就必须传几个值,并且类型和顺序一致。

传入的数据:实参。

定义的参数:形参。

//类的定义
public class Person {

//   属性的定义
  public   String name;
  public   double weight;

  //方法的定义
  public   void   jianfei(){
      //方法体,解决问题的过程
      System.out.println(name+"开始体重为"+weight);
      weight=100;
      System.out.println("经过不懈的努力,体重减为"+weight);

  }

  public   void   jianfei(double   w,int a){
      //方法体,解决问题的过程
      System.out.println(name+"开始体重为"+weight);
      weight=w;
      System.out.println("经过不懈的努力,体重减为"+weight);

  }

  //主方法:程序执行的入口
  public static void main(String[] args) {
      Person p=new   Person();
      Person p2=new   Person();

      p.name="老于";
      p.weight=200;
      p.jianfei();

      p2.name="老王";
      p2.weight=300;
      p2.jianfei();

      p2.jianfei(80,10);
      p2.jianfei(90,20);

  }

}

4、属性和参数的区别

属性:对象的数据。随对象长久存在

参数:方法体内的数据。方法调用时存在,执行完毕销毁。临时的局部变量。

八、方法的重载overload

1、定义

在同一个类中,多个方法的方法名相同但是参数必须不同的现象。

2、参数不同的情况:

(1)参数个数不同

(2)参数个数相同:对应顺序的类型至少有一个不同。

参数名不能作为判断的依据,因为调用时跟参数名无关!!

3、案例

public class JiSuanQi {

  public void   jia(int a,int b){
      System.out.println(11);
      System.out.println(a+b);
  }

  public   void jia(double a,double b){
      System.out.println(22);
      System.out.println(a+b);
  }

//   public   void jia(double c,double d){
//       System.out.println(d+c);
//   }

  public   void   jia(double   a,int b){
      System.out.println(33);
      System.out.println(a+b);
  }

  public   void   jia(int a,double b){
      System.out.println(44);
      System.out.println(a+b);
  }

  public   void jia(int a,int b,int c){
      System.out.println(55);
      System.out.println(a+b+c);
  }

  public void   jian(double   a,double b){
      System.out.println(a-b);
  }


  public static void main(String[] args) {
      JiSuanQi   jsq=new JiSuanQi();
      jsq.jia(10,20);
      jsq.jia(10.0,20.0);
      jsq.jia(10,20.0);
      jsq.jia(10.0,20);
      jsq.jia(10,20,30);

      jsq.jian(10,20);
  }
}

九、方法的返回值类型

1、返回值

方法调用结束时,向外输出一条数据。这条数据就叫返回值。

调用后,返回值可以在后面的程序中使用。

2、无返回值类型

不返回数据。

使用关键字void表示。

3、有返回值类型

使用具体的数据类型表示。

一旦定义了一个方法有返回值,这个方法执行结束必须返回一条该类型的数据。

返回值语句:

return 数据;

返回值和打印区别:

完全是没有任何交集的两个东西。

返回值作用,将方法体内的数据输出,供调用结束后,后面的程序获取和使用。

打印,将数据显示在控制台上。

4、return语句

(1)第一种

return 数据;

用在有返回值的方法体中。

返回一条数据,然后结束方法体。

(2)第二种

return;

用在没有返回值的方法体。

不返回数据,仅仅表示方法体执行的结束。

public class JiSuanQi2 {

   public   void  jia(int  a,int  b){
       int  sum=a+b;
       System.out.println(sum);
  }

   public   int  jia2(int  a,int  b){
       int  sum=a+b;
       return   sum;
  }


   public static void main(String[] args) {
       JiSuanQi2    j2=new JiSuanQi2();
       j2.jia(10,20);
//       int ss2=j2.jia(10,20);

       int  ss=j2.jia2(10,20);
       System.out.println(ss);

  }
}

5、return和打印语句的区别

return 返回一条数据供后续程序使用;没有打印功能。

打印语句 将数据打印到控制台。没有返回值功能。

十、构造器

1、类和对象的关系

类是创建对象的模板。

对象是类的具体化。

2、如何创建类的对象呢?

构造器是创建对象的工具。

构造器是定义在类中,每一个类必须有构造器。

如果你在类中没有定义构造器,系统会提供一个缺省的无参构造器。

3、构造器的定义

语法:

[修饰符] 类名([参数]){

//方法体:对象属性的初始化代码

}

注意:构造器的名字必须和类名相同!!

构造器也叫构造方法,但不是方法。

构造器创建对象的,方法是解决问题的过程。

public class Student {

//   属性
   public   int   number;
   public   String  name;
   public   String  sex;
   public   int     score;

//   方法
   public   void   display(){
       System.out.println(number);
       System.out.println(name);
       System.out.println(sex);
       System.out.println(score);
  }


   //构造器的定义
   public  Student(){

  }

   public   Student(int  num,String nm){
       number=num;
       name=nm;
  }

   public   Student(int  num,String nm,String  s,int  sr){
       number=num;
       name=nm;
       sex=s;
       score=sr;
  }

}

4、调用构造器创建对象

类名 对象名=new 构造器名(实参);

执行过程:

/**
        * 通过类名在方法区中找到这个类,(如果找不到,现加载类到方法区)
        * 在堆中开辟对象空间,
        * 将类中的属性和方法,赋予堆中的对象,
        * 传参
        * 执行方法体
        * 返回对象的首地址
        */

5、构造器的重载

在同一个类中定义多个构造器的现象。

他们的参数必须不同,因为构造器的名字和类名必须相同。

构造器的方法体主要用于初始化创建的对象属性。

提供了多种初始化的方案。

十一、this关键字

1、第一种用法

同一个类的成员变量之间不能重名;

局部变量如果作用域有交集,不能重名;

成员变量和局部变量(参数)可以重名。

当参数或局部变量,和成员变量重名时,在方法体中直接访问的是参数或局部变量,成员变量被隐藏。

我们使用this.成员变量名来访问被隐藏的属性。

public class WuMingFen2 {

   public   String theMa;
   public   int quantity;
   public   boolean likeSoup;
   
   public   void   setTheMa(String theMa){
       this.theMa=theMa;
  }


   public  WuMingFen2(String  theMa,int  quantity,boolean  likeSoup){
       this.theMa=theMa;
       this.quantity=quantity;
       this.likeSoup=likeSoup;
  }
}    

原因:this表示的是当前对象!!!

2、第二种用法

this当前类的构造器!!!

通过在一个构造器中调用另外一个构造器,从而减少构造器中重复代码的编写。

调用时,使用this(实参);

public  WuMingFen2(String  theMa,int  quantity,boolean  likeSoup){
      this.theMa=theMa;
      this.quantity=quantity;
      this.likeSoup=likeSoup;
  }

  public WuMingFen2(String theMa,int quantity){
//       this.theMa=theMa;
//       this.quantity=quantity;
//       likeSoup=true;
//System.out.println();
      this(theMa,quantity,true);
  }

  public WuMingFen2(){
//       theMa="酸辣";
//       quantity=2;
//       likeSoup=true;
      this("酸辣",2,true);
  }

注意:this(..)语句必须时构造器方法体中的第一条语句。

posted @ 2022-02-22 11:34  WhileGo  阅读(53)  评论(0)    收藏  举报