JAVA基础——面向对象

面向对象

一、什么是面向对象？

面向对象是当今主流的一种程序设计理念和设计规范，它取代了早期的“结构化”过程设计开发技术，主张一切皆为对象，程序以人的思维模式去解决问题。面向对像的程序是由类组成的，每个类包含对用户公开的特定功能部分和隐藏的实现部分。

二、面向对象三大特征：封装、继承、多态

三、类：对现实生活中事物的描述

    对象：就是这类事物，实实在在存在的个体

四、封装

1是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

2好处：将变化隔离、便于使用、提高重用性、提高安全性。

3封装原则：将不需要对外提供的内容都隐藏起来

     把属性都隐藏，提供公共方式对其访问。

4函数--最小封装体？类也是.....

五、构造函数
1、构造函数名与类名相同、不用定义返回值类型、不可以写return语句。作用：用于给对象进行初始化。

2、对象（实体？）一建立，就会调用与之对应的构造函数

3、类中没有定义构造函数，那么系统会默认给该类加入一个空参数的构造函数。有自定义构造函数，则默认的构造函数不存在。

4、重载的构造函数，以及使用不同的构造函数对对象进行初始化。

5、一般函数和构造函数不同：写法、运行（1、构造函数在对象一建立就运行给对象初始化，而一般方法是对象调用才执行，是给对象添加对象具备的功能、一个对象建立。2、构造函数只运行一次，一般方法可以被该对象调用多次）。

六、构造代码块

1、作用：给对象进行初始化。对象一建立就运行，而且优先于构造函数执行

2、与构造函数区别：构造代码块是给所有对象进行统一初始化，而构造函数是给对应对象初始化。

3、示例代码： ｛System.out.println("Person code run");｝

七、this关键字

1、用于区分局部变量与成员变量重名情况。

2、this为什么能解决这个问题？代表什么？

  this代表本类的对象；this代表它所在函数所属对象的引用--简单说哪个对象在调用this所在的函数，this就代表哪个对象。

3、代码练习  

需求：给人定义一个比较年龄是否相同的功能。是否同龄人。

关键代码： public boolean compare(Person p)

       {

            return this.age==p.age;

       }

4、this应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，用this表示这个对象。  但凡本类功能内部使用了本类对象，都用this表示。

5、this语句：用于构造函数间互相调用。构造函数间调用只能用this语句。this语句只能放在构造函数第一行（初始化要先执行）

八、static关键字

1、修饰成员（成员变量，成员函数）。static修饰的成员被对象所共享。

2、static修饰的成员除了可以被对象调用外，还可以直接被类名调用。类名.静态成员。

3、特有内容随着对象存储，在堆内存中。

4、堆内存、栈内存、方法区（共享区、数据区）（方法区存放类中的方法，共享数据）。

5、static特点：随着类的加载而加载；优先于对象存在；被所有对象共享；直接被类名调用。

6、实例变量和类变量的区别：

a.存放位置：类变量随着类的加载而存在于方法区中。实例变量随着对象的建立而存在于堆内存中。

b.生命周期：类变量生命周期最长，随着类的消失而消失，实例变量生命周期随着对象的消失而消失。

7、静态使用注意事项：

a、静态方法只能访问静态成员；

b、静态方法中不可以定义；

c、主函数是静态的。this、super关键字（因为静态优先于对象存在，所以静态中不可以出现this）。

8、静态利弊：利--对对象的共享数据进行单独空间的存储，节省空间；可以被类名直接调用。

   弊端--生命周期过长；访问出现局限性。

九、main函数

1、pubilc static void main(String[] args)

主函数：是一个特殊的函数，作为程序的入口，可以被jvm调用。

主函数的定义：

public：代表着该函数的访问权限是最大的。（虚拟机访问）

static: 代表主函数随着类的加载就已经存在了。

void  : 主函数没有返回值。

main  ：不是关键字，特殊单词，jvm识别。

（String[] arr）: 函数的参数，参数类型是一个数组，该数组中的元素是字符串。--字符串类型的数组。

2、主函数是固定格式的：jvm识别。

3、jvm在调用主函数时，传入的是new String[0];

4、调用时传入字符串数组： java 类名 元素1 元素2... 

十、静态代码块

1、class StaticCode

{

        static

   {

    System.out.println("xx");

   }

}

2、特点：随着类的加载而执行，只执行一次，优先于主函数。用于给类进行初始化（不用对象进行初始化的情况）。

3、静态代码块--给类初始化；构造代码块--给对象初始化；构造函数--给对应对象初始化。

十一、对象初始化过程

1、Person p = new Person("zhangsan",20);

这句话做了什么事情：

2、因为new用到了Person.class，所以会先找到Person.class文件并加载到内存中。

3、执行该类中的static代码块，如果有的话，给Person.class类进行初始化。

4、在堆内存中开辟空间，分配内存地址。

5、在堆内存中建立对象的特有属性，并进行默认初始化。

6、对属性进行显示初始化。

7、对对象进行构造代码块初始化。

8、对对象进行对应的构造函数初始化。

9、将内存地址付给栈内存中的p变量。

十二、单例设计模式
解决的问题：保证一个类在内存中的对象唯一性。

比如：多程序读取一个配置文件时，建议配置文件封装成对象。会方便操作其中数据，又要保证多个程序读到的是同一个配置文件对象，就需要该配置文件对象在内存中是唯一的。

Runtime()方法就是单例设计模式进行设计的。

如何保证对象唯一性呢？

思想：

1，不让其他程序创建该类对象。

2，在本类中创建一个本类对象。

3，对外提供方法，让其他程序获取这个对象。

步骤：

1，因为创建对象都需要构造函数初始化，只要将本类中的构造函数私有化，其他程序就无法再创建该类对象；

2，就在类中创建一个本类的对象；

3，定义一个方法，返回该对象，让其他程序可以通过方法就得到本类对象。（作用：可控）

代码体现：

1，私有化构造函数；

2，创建私有并静态的本类对象；

3，定义公有并静态的方法，返回该对象。

---------------------------------------------

//饿汉式

class Single{

private Single(){} //私有化构造函数。

private static Single s = new Single(); //创建私有并静态的本类对象。

public static Single getInstance(){ //定义公有并静态的方法，返回该对象。

return s;

}

}

---------------------------------------------

//懒汉式:延时加载方式。

class Single2{

private Single2(){}

private static Single2 s = null;

public static Single2 getInstance(){

if(s==null)

s = new Single2();

return s;

}

}

 

懒汉式和饿汉式的比较:（饿汉式是先初始化对象，懒汉式是对象调用方法时才初始化，叫做对象的延时加载）
  饿汉式是线程安全的,在类创建的同时就已经创建好一个静态的对象供系统使用,以后不在改变。
  懒汉式如果在创建实例对象时不加上synchronized则会导致对对象的访问不是线程安全的。
  推荐使用第一种 

Ps：枚举实现单例的情况：

enum TestSingleton {  

  INSTANCE;  

  public static TestSingleton getInstance() {  

    return INSTANCE;  

  }  

}  

 

十三、继承
好处：

1：提高了代码的复用性。

2：让类与类之间产生了关系，提供了另一个特征多态的前提。

 

注意：

子类中所有的构造函数都会默认访问父类中的空参数的构造函数，因为每一个子类构造内第一行都有默认的语句super(); 

如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super语句指定要访问的父类中的构造函数。

如果子类构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数。

 

十四、多态
体现：父类引用或者接口的引用指向了自己的子类对象。//Animal a = new Cat();

多态的好处：提高了程序的扩展性。

多态的弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)

多态的前提：

1：必须要有关系，比如继承、或者实现。

2：通常会有覆盖操作。