程序设计基础·Java学习笔记·面向对象（上）

Java程序设计基础之面向对象（上）

（自适应学习进度而进行记录的笔记，希望有一些小小的用处吧（＾∀＾●）ﾉｼ）

（新人上路，望多指教，如有错误，望指正，万分感谢(oﾟvﾟ)ノ）

目录

一、面向对象

（一）面向对象程序设计（Object Oriented Programming，OOP）

（二）包与类（package & class）

（三）对象、方法与属性（Object & Methods & Properties）

（四）方法（Method）

（五）构造器（Constructor）

一、面向对象

　　（一）面向对象程序设计（Object Oriented Programming，OOP）

　　1.在Java中，程序由面向对象为核心进行设计，该方法认为程序由一系列对象组成。类是对现实世界的抽象，包括表示静态属性的数据和对数据的操作，对象是类的实例化。 对象间通过消息传递相互通信，来模拟现实世界中不同实体间的联系。 在面向对象的程序设计中，对象是组成程序的基本模块。

　　2.理解：在Java中。如果要实现一个方法，那么首先，我们需要回答一些问题。1、这个方法所要做的事情是什么；2、这个方法的对象是谁；

　　　根据这两个问题，我们就拥有了创建一个方法最基础的两个元素：对象与成员方法，对象是指方法的实例化，即在一个具体的项目事件中的“谁”的问题，回答的就是问题2。除此之外【成员方法】也叫方法，回答的是“所作的事情是什么？”

　　　此外，在日常生活中的问题，我们通常是一群人做一些事情，那么我们“一群人”就是一个“类”，在这个类中，我们会拥有一些相同的特征，这个相同特征我们就称之为“属性”，也就是【成员变量】，而我们所作的事情，做事情的方法，在Java中我们用【成员方法】进行定义。而理解了“谁”在“做什么”，我们也就明白了面向对象的基本原理，也就是面向对象程序设计。

　　3.面向对象的三个特性：封装、继承、多态（在下文中会具体谈到）

　　（二）包与类（package & class）

　　1.理解：Java中，可以用包对类进行分类存储。包与类的形式类似于我们日常使用文件的文件夹的形式，文件 = 类，文件夹 = 包；

　　2.包名：包名一律用小写完成，如果多个单词则直接连接，如：methodloading、methodcall；

　　3.类名：类名一般除了每个单词外都用小写完成，单词首字母用大写，如果多个单词则直接连接，如：MethodLoading、MethodCall；

　　4.包的使用：

　　　包：包中可以继续创建包，构成包的叠加，表示方法：package01.package02.package03……使用小数点进行连接；

　　　引包：包的调用，需要用到关键词import，如果要调用包的所有文件，则使用 * ；即：

　　　　import package01;　　
　　　　import package01.package02;　　
　　　　import package01.*;

　　　第二种引包的方式：在实例化时，实例化对象中加入包名，即可完成调用，即：

　　　　package01.getAge a = new package01.getAge;

　　5.类的使用：

　　　类的写法：修饰词 class 类名{　　}；

　　　类的修饰词：abstract　　final　　private　　public；　　（暂时还没学到，先不做记录，插个眼罢）

　　　类的关键词：extends关键词，通过extends可以将两个类进行父子类的定义，即将extends前类定义为extends后类的子类

　　　　　　　　　

　　（三）对象、方法与属性（Object & Methods & Properties）

　　1.对象：前文说到，对象在Java中是方法的实例化，定义一个新对象，就能对方法进行执行、调用等一系列的操作。换而言之，如果要使用调用方法，则一定要实例化对象。毕竟，只是有模板还不够，要实现具体的东西，仍然要往树丫上填上绿叶与红花。

　　2.方法：在Java中，我们会把要做的事情放入方法中，然后把这个方法进行【封装】，当下一次要用到时，可以进行调用或是【继承】。

　　3.属性：除了方法以外，我们的每一个对象都会有不同的属性，这些属性在很大部分中可能都是重复的，这个时候我们所准备的属性就可以重复进行调用，节约很多的内存冗余。这种【继承】的思想，也是Java面向对象中的重要思想。

　　　Example01.有一个代表着人类的Person类，他的属性有name名字、age年龄、sex性别等，他也有方法可以打印name、age、sex；此时，我们有一个新的类Student，他自然也需要属性name名字、age年龄、sex性别等，这时，我们就可以从Person类中直接调用这些属性，当然，也可以调用Person类中的方法。

　　4.属性的写法：修饰词 类型 属性名；（可以赋值，也可以不赋值。当不赋值时，会自动生成一个为0、null、false……的值）

　　  修饰词：由大到小依次为public　　protected　　default(缺省)　　private

　　　　　　　　//修饰词所能使用的范围：

修饰词	类	包	子类	任何地方
private	√
default	√	√
protected	√	√	√
public	√	√	√	√

　　5.方法的写法：修饰词 返回值 方法名（　　）{　　}

　　　static：静态方法只能调用静态变量与静态方法；

　　　返回值：当返回值为void的时候，方法内不需要写返回值，此时表示返回0；当返回值为一个确定的类型时，如String、double等，需要手动添加返回值return，返回值必须与确定的类型相同。

　　　小括号：小括号中是可以加变量的，此时加入进去的变量被称为形参，形参进行书写时，格式是（数据类型 形参名），同时如果不需要形参时，括号可以为空但不能不写。

　　　大括号：大括号中的内容就是方法的具体内容；

　　6.对象的实例化：类名 对象名称 = new 类名（）；

　　　实例化时，前后类名可以不进行对应，此时情况为前后类为父子类。前类为父类，后类为子类。此时如果进行调用，那么调用的如果时成员变量，不能调用子类中的成员变量，只能在父类的成员变量中进行调用（一个引用类型变量如果声明为父类的类型，但实际引用的是子类的对象，那么该变量就不能再访问子类中添加的属性和方法。）。如果此时调用的成员方法，那么调用的方法是子类中的方法而不是父类，也就是后类的方法。

　　（四）方法（Method）

1.方法也称成员方法，他类似于函数，用于描述对象的行为；

　  2.方法的调用：图解（还没画）JVM模型

3.方法的可变个数的参数：

　　　方法一：数组

　　　我们定义一个数组，通过往数组中添加成员变量来完成可变个数的参数的记录

public class Person {
 public void printInfo(String[] args){
        for(int i = 0 ; i < args.length ; i++){
            System.out.println(args[i]);
        }
    }
}

public static void main(String[] args) {
        Person p = new Person();
        //通过数组定义，输入字符串数组args，实现方法的可变个数的参数
        String[] x = new String[]{"Tom","10","男"} ;
        p.printInfo(x);
        //如若进行新参数的定义，则进行新数组的定义即可实现
        String[] y = new String[]{"北京省xxx","13100225588","530225312052552"}  ;
        p.printInfo(y);
}

　　　方法二：Java特定的迭代方式

　　　我们通过特定的方式“...”来对参数实现可变个数的记录

public class Person {
  public void printInfoo(String... args){
        for(int i = 0 ; i <args.length ; i++){
            System.out.println(args[i]);
        }
    }
}

public static void main(String[] args) {
 p.printInfoo("张三","18","女","云南省xxx","18055663322","568759522568555");
 }

　　4.方法的重载：Java中，允许在一个程序中定义多个名称相同，但是参数的类型或个数不同的方法，这就是方法的重载

public class test03 {
    //方法的重载
    public void mOL (int x){
            System.out.println("x="+(x*x));
        }

    public void mOL(int x,int y){
        System.out.println("x="+(x*x+y*y));
        }

    public  void mOL(String x){
            System.out.println("x="+x);
    }

    public static void main(String[] args) {
        test03 t = new test03();
        t.mOL(2);
        t.mOL(6,5);
        t.mOL("Tom");
    }

　　5.方法的递归：在Java中，一个方法的内部调用自身的过程

　　　需要注意的是，递归必须要有结束条件，不然就会陷入无限递归的状态，永远无法结束调用；

　　　每次递归都需要逐步递减，直到有结束值；

public static int getSum(int n){
        if(n == 1){
            return 1;
        }
        int temp = getSum(n - 1);
        return temp + n;
    }

    public static void main(String[] args) {
        int sum = getSum(4);
        System.out.println("Sum = " + sum);
    }

　　6.匿名调用

　　匿名调用方式： 类名 对象名 = new 调用类名（）.方法名（）；

public class Circle {
 public double area(double r){
        return r*r*3.14;
    }
}

public class test02 {
    public static void main(String[] args) {
        //匿名调用测试
        double area = new Circle().area(3);
        System.out.println("半径为3的圆的面积为：" + area);
    }
}

　　7.toString()方法

　　　（1）toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址；

　　　（2）在进行String与其它类型数据的连接操作时，自动调用toString()方法；

Person p = new Person;
System.out.println("p=" + p);
//这两句相等；
System.out.println("p=" + p.toString());

　　　（3）可以根据需求在用户自定义类型中重写toString类方法；

　　　（4）基本类型数据转换为String类型时，调用了对应包装类的toString()方法；

　　（五）构造器（Constructor）

　　1.构造器也就是构造方法，在Java中，构造方法在类实例化对象时会被自动调用，可以把他看作类的一个特殊成员；

　　2.构造器的写法：修饰词 方法名（　　）{　　}

　　3.条件要求：完成构造方法需要同时满足以下三个条件

　　　方法名与类名相同；

　　　在方法名的前面没有返回类型的声明；

　　　在方法中不能使用return语句返回一个值，但是可以单独写return语句来作为方法的结束。

　　4.构造器的重载：方法可以重载，构造方法也可以重载

　　　在构造器中对方法进行输入，直接使用 new 类名 即可完成；

//构造器重载
//使得对象的创建更加灵活，方便创建各种不同的对象
//构造器重载，参数列表必须不同
public class Person {
    public Person(int a){}
    public Person(String b){}
    public Person(int a,String b){}
}

public class test {
    public static void main(String[] args) {
        new Person(10);
        new Person("张三");
        new Person(30,"李四");
    }
}