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

大家好，欢迎来到IT知识分享网。

1.面向对象的基本概念

1.1对象的基本概念

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

2.类

2.1类的基本概念

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

2.2类的定义

具体类的形式：

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

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

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方法的定义

3.2方法的调用

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

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构造方法

 /*构造方法的演示：*/ //人：编号，姓名，年龄，住址 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对象的创建

创建对象的一般格式为：

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

类名 对象名；

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

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

4.2对象的使用

对象名. 成员变量；

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）向下转型：子类的引用指向子类对象，过程中必须要采用强制转型。

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