JAVA基础知识：面向对象程序设计基础

1.面向对象的基本概念

1.1对象的基本概念

（1）面向对象（OOP）： 是一种程序设计方法，是一种编程思想，基于面向过程而言。基本思想是使用对象、类、继承、封装、消息等基本概念类进行程序设计。
（2）对象： 是系统中用来描述客观事物的一个实体，是构成系统的一个基本单位。
先做初步的了解，后面第四标题会做细致的讲解。

2.类

2.1类的基本概念

（1）类: 是引用类型，类的对象存放在堆中。对象是指具体的事务，而类是指一类事务。

2.2类的定义

(1)一个类主要有三个部分组成：
（1.1）构造方法：用来创建对象
（1.2）成员变量：也称属性，用来表示对象的状态
（1.3）方法：对象的行为
(2)类的一般形式：

具体类的形式：

(3)类声明：由4个部分组成：类修饰符、类关键字class、声明父类、实现接口。其一般形式如下：

[public] [abstract] [fimal] class类名 [extends 父类名] [implements接口列表]{
			...
			*
}

(3.1)类修饰符：
public: 这个public关键字声明了类可以在其他类中使用。其缺省时，该类只能被同一个包下的其他类使用。
abstract: 声明这个类是一个抽象类，这个类不能被实例化，只用于衍生子类，抽象类中可以包含抽象方法。
final： 声明该类不能被继承，不能有子类。

2.3 成员变量和局部变量

（1）声明成员变量 的一般形式：

[可访问性修饰符] [static] [final] [transient] [volatile] 类型 变量名
上述属性用括号括起来，表示它们都是可选项，其含义分别为：
[可访问性修饰符]： 说明该变量的可访问属性，该修饰符可分为public、protected、package和private
[static]： 说明该成员变量是一个静态变量（类变量），以区别一般的实例变量。
[final]： 说明是一个常量
[transient]： 声明瞬态变量，瞬态变量不是对象的持久部分。
[volatile] ： 声明一个可能同时被并存运行中的几个线程所控制和修饰的变量

（2）局部变量： 在方法中声明的变量以及方法中参数称为局部变量。局部变量除了作用范围仅适用本方法之外，其余均与上面讨论的成员变量是一致。
示例：

class Data{
 int x=12,y=5;  //成员变量
 public void sum(){
	int s;   //局部变量
	s=x+y;
 }
}

作用域： 静态变量 > 成员变量 > 局部变量

3.成员方法

3.1方法的定义

（1）在Java中，必须通过方法才能完成对类和对象的属性操作。成员方法中只能在类的内部声明并加以实现。
（2）方法定义的一般形式：

方法定义的介绍：
返回类型： 可以是基本数据类型或引用类型，它是方法体中通过return语句返回值得数据类型，也称该方法的类型。当该方法为无返回值时，需要用void作方法的类型。
方法的参数： 方法名后小括号中的内容称为方法的参数。当小括号里是空的，这样的方法称为无参方法，如果括号里面至少有一个参数参数（称为形式参数，简称形参）
方法体一般由三部分组成：
（1）定义方法所需的变量，定义在方法内部的变量称为局部变量。
（2）完成方法功能的具体实现。
（3）由return语句返回方法的结果。
注意： 方法不允许嵌套定义，即不允许一个方法的定义放在另一个方法的定义中，一个类中可以定义多个方法。

3.2方法的调用

1、方法调用的语法行式：
通常把调用其他方法的方法称为主调方法，被其他方法调用的方法称为被调方法。

函数名(实际参数1,实际参数2,…,实际参数n);

形参和实参：
（1）行参：全称“形式参数”是在定义方法名和方法体的时候使用的参数，用于接收调用该方法时传入的实际值。
（2）实参：全称“实际参数”，一个方法在被调用语句中，其参数被称为实际参数，简称实参，也就是在调用方法时传递给该方法的实际值。
注意： Java程序的运行总是从main()开始，main方法又称为主方法，它可以调用任何其他的方法，但不允许被其它方法调用。除了main方法以外，其他任何方法的关系都是平等的，可以相互调用。
示例：求1+2+3+4+…+100=?

public class Example {
    public static void main(String[] args) {
        int sum=mysum(100); //100表示实参
        System.out.println("1+2+3+4+...+100="+sum);
    }

    private static int mysum(int n) { //n表示形参
        int i, s=0;
        for (i=1;i<=n;i++){
            s=s+i;
        }
        return s;
    }
}

3.3方法重载与方法重写

（1）重载（Overloading）： 是指在同一个类中定义了多个同名的方法，但参数的个数或者参数类型不同。（例：println()、Arrays.sort()、构造方法）.
（2）重写（Overriding）： 是指在继承的情况下，子类中定义了和父类中某个方法完全一样的结构，就称为把父类的方法重写了。那么调用时，就直接调用子类的这个方法，而父类方法就不在起作用。
区别： 重写是在继承情况下，是父类子类；重载是在一个类中，一个类的一个方法多个参数及参数类型不同，重载是多态的一种表现。
示例：

 /*方法重载的演示：*/
public class Example {
    public static void main(String[] args) {
        int sum=mysum(100);
        int mysum = mysum(1, 5);
        System.out.println("1+2+3+4+...+100="+sum);
        System.out.println("两个数的和为："+mysum);
    }
    private static int mysum(int n) {
        int i, s=0;
        for (i=1;i<=n;i++){
            s=s+i;
        }
        return s;
    }
    private static int mysum(int n,int b){
        int s;
        s=n+b;
        return s;
    }
}


/*方法重写的演示：*/
public class Example { 
    public int test1(int a,int b){
        int c;
        c=a-b;
        return c;
    }
}

public class test extends Example {
    @Override
    public int test1(int a, int b) {
        int c;
        c=a+b;
        return c;
    }
}

3.4构造方法

1.概述：
（1）构造方法是一种特殊的方法，它是一个与类同名，且没有返回值（无void）的方法。
（2）对象的创建就是通过构造方法来完成，其功能主要是完成对象的初始化。
2.分类：
（1）默认构造（无参构造）：默认构造不用写，javac编译器优化时会自动加上。
（2）带参构造（有参构造）
注意： 如果类中有带参构造方法后，javac编译器就不会再自动生成默认构造方法，此时就需要自己创建。
示例：

 /*构造方法的演示：*/
//人：编号，姓名，年龄，住址
public class User {
	//方法体内尽量用基本类型，对POJO尽量包装类型
	//属性（字段）Field，成员变量私有
	private Integer id;
	private String name;
	private Integer age;
	private String address;
	
	//构造方法，默认构造，和普通方法不同
	//特点：1. 没返回值，连void都没有，
	//	         2. 和类名必须一致
	//			 3. 默认构造是无参构造，没有参数
	public User() {	//默认构造是自动调用
		System.out.println("我是默认构造方法，自动调用");
	}
	//有参构造，方法形参
	public User(Integer id, String name) {
		//this.id代表成员变量
		//id是代表形参
		this.id = id;
		this.name = name;
	}
}

4.对象

一个对象的生命周期包括三个阶段：创建、使用和释放

4.1对象的创建

创建对象的一般格式为：

类名 对象名= new 类名（[参数列表]）;
该表达式隐含了对象声明、实例化和初始化三个部分

1）对象声明的一般形式：

类名 对象名；

对象声明并不为对象分配内存空间，而只是分配一个引用空间，对象的引用类似于指针，指向对象所在的堆地址，保证对象的安全性。

2）实例化
实例化是为对象分配内存空间和进行初始化的过程，一般形式为：

对象名 = new 构造方法（）;

4.2对象的使用

对象要通过访问对象变量或调用对象方法来使用。
通过 “.” 可以实现对对象自己的变量访问和方法的调用。
1）访问对象的变量的格式为：

对象名. 成员变量；

2）调用对象成员方法的格式为：

对象名.方法名（ [参数列表] ）；

示例：

public class User {
    private Integer id;
    private String name;
    private Integer age;
    public String address;
    //无参构造
    public User() {
    }
    //有参构造
    public User(Integer id, String name, Integer age, String address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.address = address;
    }
    //普通方法
    public void workName(Integer id, String name) {
        //利用普通方法给成员变量设置值
        this.id = id;
        this.name = name;
    }
}


public class Usertest {
    @Test
    public void workName() {
        //对象的创建
        User user = new User();
        //访问对象的变量
        String address = user.address;
        System.out.println(address);
        //调用对象的方法
        user.workName(7, "王七");
        System.out.println(user);
    }
}

4.3释放对象

当不存在对一个对象的引用时，该对象成为一个无用对象，Java的垃圾收集器（GC）自动扫描对象的动态内存区，把没有引用的对象作为垃圾收集起来并释放。也可以用其他一些办法来释放对象所占用的内存。例如：使用系统的System.gc();以及使用finalize方法将对象从内存中清楚。

5.面向对象特性

面向对象的特性：封装性、继承性、多态性。下面给大家详细介绍三大特性。

5.1封装性

1.概念： 封装是把对象的属性和操作（服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现的细节。
2.访问： 对数据的访问只能通过已定义的接口。
3.属性私有后无法直接访问：private修饰符修饰的就叫做私有
（1）修改值：可以通过set方法修改。
（2）获取值：可以通过get方法获取。
4.特点：
（1）减少代码的耦合。
（2）对外隐藏细节，暴露的越少，安全性越好。
（3）规范统一入口，控制数据访问。
5.修饰符： 用来控制一个类，或者类中的成员的访问范围。

使用原则： 尽量使用小范围。

5.2继承性

1.概念： 继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
2.特点：
（1）使用extends关键字修饰。
（2）相当于子类把父类的功能复制了一次。
（3）java只支持单继承，继承可以传递，间接实现了多继承。
（4）不能继承父类的构造方法和私有成员，私有方法，即private修饰的
（5）继承多用于功能的修改，子类可以拥有父类的功能的同时，还可以进行功能拓展。
（6）new 子类时，会先调用父类的构造方法创建父类，然后再创建子类。
（7）两种方式：实现继承 extends 、接口继承 implements。
（8）组合优先于继承。
3.作用： 实现代码的复用，减少代码量、方便维护
示例：

/*类的继承演示：*/
class A{ //A类为父类
    void prnt(int x,int y){
        int z=x+y;
        String s="x+y=";
        System.out.println(s+z);
    }
}
class B extends A{  
    //B类是A类的子类，B类拥有自己定义的bb方法，还拥有继承于父类A的prnt方法
    String str;
    void bb(){
        System.out.println(str);
    }
}

public class Usertest {
    public static void main(String[] args) {
        B b=new B();//创建B类的实例对象b
        b.str="java学习";
        b.bb(); //bb()是实例对象b的方法
        b.prnt(3,2); //prnt()是实例对象b父类A的方法，b继承了该方法
    }
  
}

5.3多态性

1.概念： 多态是指同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。
2.实现多态的两种方式：
（1）使用父类作为方法形参实现多态。
（2）使用父类作为方法返回值实现多态。
3.多态的作用：
（1）可替换性：多态对已存在代码具有可替换性
（2）可扩展性：多态对代码具有可扩展性。增加新的子类不影响已存在类的运行和操作。实际上新加子类更容易获得多态功能。
4.多态的三个必要条件： 要有继承、要有重写，父类引用指向子类对象
（1）多态的前提是继承，没有父类子类，也就没有多态的情况产生。
（2）要有方法的重写，各自完成各自的业务，从而各个子类体现不同的特征。
（3）父类引用指向子类对象，如 A a= new B（）；
5.多态方法底层原则： 编译看左，运行看右
当使用多态调用方法时，首先检查父类中是否有该方法，如果没有，则编译报错；如果有，在去调用子类的同名方法。
6.向上造型（向上转型）和向下造型（向下转型）：
（1）向上转型：父类的引用指向子类对象（说明：向上转型时，子类对象当成父类对象，只能调用父类的功能，如果子类重写了父类的方法，就根据这个引用指向调用子类重写方法）。
（2）向下转型：子类的引用指向子类对象，过程中必须要采用强制转型。

本期内容到此结束，下期会继续给大家分享新的内容，谢谢读者的欣赏，如果觉得不错的可以关注我的博客，能实时查看我跟新的内容，点个赞，谢谢大家，下期再见！