专栏首页LanceToBigDataJavaSE(一)之类与对象

JavaSE(一)之类与对象

终于到了要学习面向对象程序设计了,其中可能很多东西以前都知道怎么去用,但是却不知道怎么来的,或者怎么样写会出错,所以今天总结起来。

一、OOP概述

  Java的编程语言是面向对象的,采用这种语言进行编程称为面向对象编程(Object-Oriented Programming, OOP)。     1)抽象(abstract)         忽略一个主题中与当前目标无关的那些方面,以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题,而只是选择其中的一部分,暂时不用关注细节。             例如:要设计一个学生成绩管理系统,那么对于学生,只关心他的班级、学号、成绩等,而不用去关心他的身高、体重这些信息     2)封装(Encapsulation)         封装是面向对象的特征之一,是对象和类概念的主要特性。封装是把过程和数据包围起来,对数据的访问只能通过指定的方式。         在定义一个对象的特性的时候,有必要决定这些特性的可见性,即哪些特性对外部是可见的,哪些特性用于表示内部状态。         通常,应禁止直接访问一个对象中数据的实际表示,而应通过操作接口来访问,这称为信息隐藏。         信息隐藏是用户对封装性的认识,封装则为信息隐藏提供支持。         封装保证了模块具有较好的独立性,使得程序维护修改较为容易。对应用程序的修改仅限于类的内部,因而可以将应用程序修改带来的影响减少到最低限度。     3)继承(inheritance)         继承是一种联结类的层次模型,并且允许和支持类的重用,它提供了一种明确表述共性的方法。         新类继承了原始类后,新类就继承了原始类的特性,新类称为原始类的派生类(子类),而原始类称为新类的基类(父类)。         派生类(子类)可以从它的基类(父类)那里继承方法和实例变量,并且派生类(子类)中可以修改或增加新的方法使之更适合特殊的需要         继承性很好的解决了软件的可重用性问题。比如说,所有的Windows应用程序都有一个窗口,它们可以看作都是从一个窗口类派生出来的。但是有的应用程序用于文字处理,有的应用程序用于绘图,这是由于派生出了不同的子类,各个子类添加了不同的特性。     4)多态(polymorphism)         多态性是指允许不同类的对象对同一消息作出响应。         多态性语言具有灵活、抽象、行为共享、代码共享的优势,很好的解决了应用程序函数同名问题。         相同类域的不同对象,调用相同方法,表现出不同的结果         例如:

            public class Person{
                public void say(){}
            }
            public class Student extends Person{
                public void say(){
                    System.out.println("I am a student");
                }
            }
            public class Teacher extends Person{
                public void say(){
                    System.out.println("I am a teacher");
                }
            }
            main:
                Person s = new Student();
                Person t = new Teacher();
                s.say();
                t.say();

二、类与对象和对象与引用的关系

2.1、类与对象的关系

类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物.           例如:我们生活中所说的词语:动物、植物、手机、电脑等等           这些也都是抽象的概念,而不是指的某一个具体的东西。           例如: Person类、Room类、Car类等           这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为 对象是抽象概念的具体实例           例如:               张三就是人的一个具体实例,张三家里的旺财就是狗的一个具体实例。能够体现出特点,展现出功能的是具体的实例,而不是一个抽象的概念.          例如:

              Student s = new Student(1L,"tom",20);
              s.study();

              Car c = new Car(1,"BWM",500000);
              c.run();

            对象s就是Student类的一个实例,对象c就是Car类的一个具体实例,能够使用的是具体实例,而不是类。类只是给对象的创建提供了一个参考的模板而已.             但是在java中,没有类就没有对象,然而类又是根据具体的功能需求,进行实际的分析,最终抽象出来的.

2.2、对象和引用的关系  

    引用"指向"对象 使用类类型、数组类型、接口类型声明出的变量,都可以指向对象,这种变量就是引用类型变量,简称引用。       在程序中,创建出对象后,直接使用并不方便,所以一般会用一个引用类型的变量去接收这个对象,这个就是所说的引用指向对象.       总结:对象和引用的关系,就如电视机和遥控器,风筝和线的关系一样。

三、方法的定义和调用

  方法一定是定义在类中的,属于类的成员。

 3.1、方法的定义

格式:  修饰符 返回类型 方法名(参数列表)异常抛出类型{...}           1)修饰符:  public static abstract final等等都是修饰符,一个方法可以有多个修饰符.例如程序入口main方法,就使用了public static这个俩个修饰符               注:如果一个方法或者属性有多个修饰符,这多个修饰符是没有先后顺序的           2)返回类型:               方法执行完如果有要返回的数据,那么就要声明返回数据的类型,如果没有返回的数据,那么返回类型就必须写void.               只有构造方法(构造器)不写任何返回类型也不写void               例如:

              public String sayHello(){
                  return "hello";
              }
              public int max(int a,int b){
                  return a>b?a:b;
                }
              public void print(String msg){
                  System.out.println(msg);
              }

              思考:声明返回类型的方法中一定要出现return语句,那么没有返回类型(void)的方法中,能不能出现return语句?               注:break和return的区别           3)方法名:               遵守java中标示符的命名规则即可.           4)参数列表               根据需求定义,方法可以是无参的,也可以有一个参数,也可以有多个参数           5)异常抛出类型               如果方法中的代码在执行过程中,可能会出现一些异常情况,那么就可以在方法上把这些异常声明并抛出,也可以同时声明抛出多个异常,使用逗号隔开即可。               例如:

              public void readFile(String file)throws IOException{
 
              }
              public void readFile(String file)throws IOException,ClassNotFoundException{
 
              }

3.2、方法调用

    在类中定义了方法,这个方法中的代码并不会执行,当这个方法被调用的时候,方法中的代码才会被一行一行顺序执行。           1)非静态方法               没有使用static修饰符修饰的方法,就是非静态方法. 调用这种方法的时候,是"一定"要使用对象的。因为非静态方法是属于对象的。(非静态属性也是一样的)               例如:

                  public class Student{
                      public void say(){}
                  }

                  main:
                      Student s = new Student();
                      s.say();
 

          2)静态方法               使用static修饰符修饰的方法,就是静态方法.  调用这种方法的时候,"可以"使用对象调用,也"可以"使用类来调用,但是推荐使用类进行调用,因为静态方法是属于类的。(静态属性也是一样的)               例如:

                  public class Student{
                      public static void say(){}
                  }

                  main:
                      Student.say();

          3)类中方法之间的调用               假设同一个类中有俩个方法,a方法和b方法 a和b都是非静态方法,相互之间可以直接调用.

              public void a(){                   b();               }               public void b(){               }  a和b都是静态方法,相互之间可以直接调用.               public static void a(){                   b();               }               public static void b(){              } a静态方法,b是非静态方法                a方法中不能直接调用b方法,但是b方法中可以直接调用a方法.               public static void a(){                   //b();报错               }               public void b(){                   a();               }               另外:在同一个类中,静态方法内不能直接访问到类中的非静态属性.

      总结:类中方法中的调用,两个方法都是静态或者非静态都可以互相调用,当一个方法是静态,一个方法是非

         静态的时候,非静态方法可以调用静态方法,反之不能。

四、调用方法时的传参

  1)形参和实参         例如:         // a = x;         public void test(int a){             //..         }         main:             int x = 1;             t.test(x);         参数列表中的a是方法test的形参(形式上的参数)         调用方法时的x是方法test的实参(实际上的参数)         注意:形参的名字和实参的名字都只是一个变量的名字,是可以随便写的,我们并不关心这个名字,而是关心变量的类型以及变量接收的值。     2)值传递和引用传递         调用方法进行传参时,分为值传递和引用传递两种。         如果参数的类型是基本数据类型,那么就是值传递。         如果参数的类型是引用数据类型,那么就是引用传递。 值传递是实参把自己变量本身存的简单数值赋值给形参.         引用传递是实参把自己变量本身存的对象内存地址值赋值给形参.         所以值传递和引用传递本质上是一回事,只不过传递的东西的意义不同而已.     3)值传递的示例

        public class Test{
            public static void changeNum(int a){
                a = 10;
            }

            public static void main(String[] args){
                int a = 1;
                System.out.println("before: a = "+a);
                changeNum(a);
                System.out.println("after: a = "+a);
            }

        }

    4)引用传递的示例

        public class Test{
            public static void changeName(Student s){
                s.name = "tom";
            }

            public static void main(String[] args){
                Student s = new Student();
                System.out.println("before: name = "+s.name);
                changeName(s);
                System.out.println("after: name = "+s.name);
            }
        }

五、this关键字

在类中,可以使用this关键字表示一些特殊的作用。

5.1、this在类中的作用

      1)区别成员变量和局部变量

          public class Student{
              private String name;
              public void setName(String name){
                  //this.name表示类中的属性name
                  this.name = name;
              }

          }

      2)调用类中的其他方法

          public class Student{
              private String name;
              public void setName(String name){
                  this.name = name;
              }
              public void print(){
                  //表示调用当前类中的setName方法
                  this.setName("tom");
              }
          }

        注:默认情况下,setName("tom")和this.setName("tom")的效果是一样的.       3)调用类中的其他构造器

          public class Student{
              private String name;
              public Student(){
                  //调用一个参数的构造器,并且参数的类型是String
                  this("tom");
              }
              public Student(String name){
                  this.name = name;
              }
          }

        注:this的这种用法,只能在构造器中使用.普通的方法是不能用的.并且这局调用的代码只能出现在构造器中的第一句.         例如:

        public class Student{
            private String name;
            //编译报错,因为this("tom")不是构造器中的第一句代码.
            public Student(){
                System.out.println("hello");
                this("tom");
            }
            public Student(String name){
                this.name = name;
            }
        }

5.2、this关键字在类中的意义  

 this在类中表示当前类将来创建出的对象.           例如:

          public class Student{
              private String name;
              public Student(){
                  System.out.println("this = "+this);
              }
              public static void main(String[] args){
                  Student s = new Student();
                  System.out.println("s = "+s);
              }
          }

          运行后看结果可知,this和s打印的结果是一样的,那么其实也就是变量s是从对象的外部执行对象,而this是在对象的内部执行对象本身.           这样也就能理解为什么this.name代表的是成员变量,this.setName("tom")代表的是调用成员方法,因为这俩句代码从本质上讲,和在对象外部使用变量s来调用是一样的,s.name和s.setName("tom")。           this和s打印出来的内存地址是一样的,使用==比较的结果为true。           例如:

          public class Student{
              public Student getStudent(){
                  return this;
              }
              public static void main(String[] args) {
                  Student s1 = new Student();
                  Student s2 = s1.getStudent();
                  System.out.println(s1 == s2);//true           
              }
          }
 
 

          例如: 类中的this是和s1相等还是和s2相等呢?

           public class Student{
              private String name;
              public void test(){
                  System.out.println(this);
              }
              public static void main(String[] args) {
                  Student s1 = new Student();
                  Student s2 = new Student();
                  s1.test();
                  s2.test();
               }
          }

        注:这句话是要这么来描述的,s1对象中的this和s1相等,s2对象中的this和s2相等,因为类是模板,模板中写的this并不是只有一个,每个对象中都有一个属于自己的this,就是每个对象中都一个属于自己的name属性一样.

六、创建与初始化对象

 使用new关键字创建的时候,除了分配内存空间之外,还会给创建好的对象进行默认的初始化以及对类中构造器的调用      那么对main方法中的以下代码:           Student s = new Student();           1)为对象分配内存空间,将对象的实例变量自动初始化默认值为0/false/null。(实例变量的隐式赋值)           2)如果代码中实例变量有显式赋值,那么就将之前的默认值覆盖掉。(之后可以通过例子看到这个现象)               例如:显式赋值               private String name = "tom";           3)调用构造器           4)把对象内存地址值赋值给变量。(=号赋值操作)

七、构造器

类中的构造器也称为构造方法,是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:         1)必须和类的名字相同         2)必须没有返回类型,也不能写void     构造器的作用:         1)使用new创建对象的时候必须使用类的构造器         2)构造器中的代码执行后,可以给对象中的属性初始化赋值             例如:

            public class Student{
                private String name;
                public Student(){
                    name = "tom";
                }
            }

    构造器重载: 除了无参构造器之外,很多时候我们还会使用有参构造器,在创建对象时候可以给属性赋值.         例如:

            public class Student{
                private String name;
                public Student(String name){
                    this.name = name;
                }
            }
 

    构造器之间的调用: 使用this关键字,在一个构造器中可以调用另一个构造器的代码。         注意:this的这种用法不会产生新的对象,只是调用了构造器中的代码而已.一般情况下只有使用new关键字才会创建新对象。         例如:

            public class Student{
                private String name;
                public Student(){
                    this();
                }
                public Student(String name){
                    this.name = name;
                }
            }

    默认构造器:  在java中,即使我们在编写类的时候没有写构造器,那么在编译之后也会自动的添加一个无参构造器,这个无参构造器也被称为默认的构造器。         例如:

        public class Student{
 
        }

        main:

            //编译通过,因为有无参构造器
            Student s = new Student();
 

        但是,如果我们手动的编写了一个构造器,那么编译后就不会添加任何构造器了         例如:

        public class Student{
            private String name;
            public Student(String name){
                this.name = name;
            }
        }

        main:

            //编译报错,因为没有无参构造器
            Student s = new Student();

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • JavaSE(四)之接口、访问控制

    上面我们学习了几个修饰符,在开发中经常会用的到,所以必须熟练的掌握。接下来我学习一下接口和访问控制。 一、接口 一系列方法的声明,是一些方法特征的集合,一个接口...

    用户1195962
  • OOAD-设计模式(三)之创建型设计模式(5种)

    前言   前面介绍了OOAD的基础知识,现在我们来详细的说明一下GOF设计模式中的23种模式,希望大家能够学到东西! 一、工厂方法模式(Factory Meth...

    用户1195962
  • JavaSE(三)之static、final、abstract修饰符

    一、static修饰符 1.1、static变量         在类中,使用static修饰的成员变量,就是静态变量,反之为非静态变量。         ...

    用户1195962
  • 微信小程序for循环里条件判断

    今天踩了一下午的坑,但是确实很简单的问题。

    疯狂的小程序
  • 小知识点 -- nodejs中的console.log打印输出在哪里?

    今天在前端零基础课中,讲nodejs当中的用express来设置路由的时候,有个例子是这样的, html代码: <form action="http://127...

    web前端教室
  • Akka 指南 之「第 3 部分: 使用设备 Actors」

    在前面的主题中,我们解释了如何在大范围(in the large)内查看 Actor 系统,也就是说,如何表示组件,如何在层次结构中排列 Actor。在这一部分...

    CG国斌
  • 蓝牙在小程序中的应用

    蓝牙在日常生活中广泛使用的一项技术,小程序给了我们前端工程师一个控制蓝牙的方法,带上你的设备,来看看怎么控制你的蓝牙设备吧。

    leochu2008
  • Kotlin开发的一些实用小技巧总结

    随着Google I/O大会的召开,Google宣布将支持Kotlin作为Android的开发语言,最近关于Kotlin的文章、介绍就异常的活跃。

    砸漏
  • vue切换路由并且传递参数

    用户4344670
  • SSH框架之旅-spring(1)

    Spring 是一个开源的轻量级 Java 开发框架,可以解决业务逻辑层和其他层的耦合太高的问题,它不仅可以用在 Java EE 上,对于 Java SE 同样...

    Wizey

扫码关注云+社区

领取腾讯云代金券