一、面向对象简述
 
面向对象是一种现在最为流行的程序设计方法，几乎现在的所有应用都以面向对象为主了，最早的面向对象的概念实际上是由IBM提出的，在70年代的Smaltalk语言之中进行了应用，后来根据面向对象的设计思路，才形成C++，而由C++产生了Java这门面向对象的编程语言。
 
但是在面向对象设计之前，广泛采用的是面向过程，面向过程只是针对于自己来解决问题。面向过程的操作是以程序的基本功能实现为主，实现之后就完成了，也不考虑修改的可能性，面向对象，更多的是要进行子模块化的设计，每一个模块都需要单独存在，并且可以被重复利用，所以，面向对象的开发更像是一个具备标准的开发模式。
 
在面向对象定义之中，也规定了一些基本的特征： 
 （1）封装：保护内部的操作不被破坏； 
 （2）继承：在原本的基础之上继续进行扩充； 
 （3）多态：在一个指定的范围之内进行概念的转换。
 
对于面向对象的开发来讲也分为三个过程：OOA（面向对象分析）、OOD（面向对象设计）、OOP（面向对象编程）。
 
二、类与对象的基本概念
 
类与对象时整个面向对象中最基础的组成单元。
 
类：是抽象的概念集合，表示的是一个共性的产物，类之中定义的是属性和行为（方法）； 
 对象：对象是一种个性的表示，表示一个独立的个体，每个对象拥有自己独立的属性，依靠属性来区分不同对象。
 
可以一句话来总结出类和对象的区别：类是对象的模板，对象是类的实例。类只有通过对象才可以使用，而在开发之中应该先产生类，之后再产生对象。类不能直接使用，对象是可以直接使用的。
 
三、类与对象的定义和使用
 
在Java中定义类，使用关键字class完成。语法如下：
 
class 类名称 {
         属性 (变量) ;
         行为 (方法) ;
}
 
范例：定义一个Person类
 
class Person {     // 类名称首字母大写
    String name ;
    int age ;
    public void tell() {        // 没有static
          System.out.println("姓名：" + name + "，年龄：" + age) ;
         }
}
 
类定义完成之后，肯定无法直接使用。如果要使用，必须依靠对象，那么由于类属于引用数据类型，所以对象的产生格式（两种格式）如下：
 
（1）格式一：声明并实例化对象
 
类名称 对象名称 = new 类名称 () ;
 
（2）格式二：先声明对象，然后实例化对象： 
 
类名称 对象名称 = null ;
对象名称 = new 类名称 () ;
 
引用数据类型与基本数据类型最大的不同在于：引用数据类型需要内存的分配和使用。所以，关键字new的主要功能就是分配内存空间，也就是说，只要使用引用数据类型，就要使用关键字new来分配内存空间。
 
当一个实例化对象产生之后，可以按照如下的方式进行类的操作： 
 对象.属性：表示调用类之中的属性； 
 对象.方法()：表示调用类之中的方法。
 
范例：使用对象操作类
 
package com.wz.classandobj;

class Person { 
    String name ;
    int age ;
    public void get() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Person per = new Person() ;// 声明并实例化对象
            per.name = "张三" ;//操作属性内容
            per.age = 30 ;//操作属性内容
            per.get() ;//调用类中的get()方法
        }
}
 
运行结果：
 
姓名：张三，年龄：30
 
以上完成了一个类和对象的操作关系，下面换另外一个操作来观察一下：
 
package com.wz.classandobj;

class Person { 
    String name ;
    int age ;
    public void get() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Person per = null;//声明对象
            per = new Person() ;//实例化对象
            per.name = "张三" ;//操作属性内容
            per.age = 30 ;//操作属性内容
            per.get() ;//调用类中的get()方法
        }
}
 
运行结果：
 
姓名：张三，年龄：30
 
那么，问题来了，以上两种不同的实例化方式有什么区别呢？ 
 我们从内存的角度分析。首先，给出两种内存空间的概念： 
 （1）堆内存：保存对象的属性内容。堆内存需要用new关键字来分配空间； 
 （2）栈内存：保存的是堆内存的地址（在这里为了分析方便，可以简单理解为栈内存保存的是对象的名字）。
 
 
任何情况下，只要看见关键字new，都表示要分配新的堆内存空间，一旦堆内存空间分配了，里面就会有类中定义的属性，并且属性内容都是其对应数据类型的默认值。
 
于是，上面两种对象实例化对象方式内存表示如下： 
 
 
两种方式的区别在于①②，第一种声明并实例化的方式实际就是①②组合在一起，而第二种先声明然后实例化是把①和②分步骤来。
 
另外，如果使用了没有实例化的对象，结果如何？ 
 如下：
 
package com.wz.classandobj;

class Person { 
    String name ;
    int age ;
    public void get() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Person per = null;//声明对象
            //per = new Person() ;//实例化对象
            per.name = "张三" ;//操作属性内容
            per.age = 30 ;//操作属性内容
            per.get() ;//调用类中的get()方法
        }
}
 
运行结果：
 
Exception in thread "main" java.lang.NullPointerException
    at com.wz.classandobj.TestDemo.main(TestDemo.java:15)
 
此时，程序只声明了Person对象，但并没有实例化Person对象（只有了栈内存，并没有对应的堆内存空间），则程序在编译的时候不会出现任何的错误，但是在执行的时候出现了上面的错误信息。这个错误信息表示的是“NullPointerException（空指向异常）”，这种异常只要是应用数据类型都有可能出现。
 
四、对象引用传递初步分析
 
引用传递的精髓：同一块堆内存空间，可以同时被多个栈内存所指向，不同的栈可以修改同一块堆内存的内容。
 
下面通过若干个程序，以及程序的内存分配图，来进行代码的讲解。
 
我们来看一个范例：
 
class Person {     
         String name ;
         int age ;
         public void tell() {        
                   System.out.println("姓名：" + name + "，年龄：" + age) ;
         }
}
public class TestDemo {
         public static void main(String args[]) {
                   Person per1 = new Person() ;         // 声明并实例化对象
                   per1.name = "张三" ;
                   per1.age = 20 ;
                   Person per2 = per1 ;  // 引用传递
                   per2.name = "李四" ;
                   per1.tell() ;
         }
}
 
对应的内存分配图如下：
 
 
再来看另外一个：
 
class Person {
         String name ;
         int age ;
         public void tell() {
                   System.out.println("姓名：" + name + "，年龄：" + age) ;
         }
}
public class TestDemo {
         public static void main(String args[]) {
                   Person per1 = new Person() ;         // 声明并实例化对象
                   Person per2 = new Person() ;
                   per1.name = "张三" ;
                   per1.age = 20 ;
                   per2.name = "李四" ;
                   per2.age = 30 ;
                   per2 = per1 ;// 引用传递
                   per2.name = "王五" ;
                   per1.tell() ;
         }
}
 
对应的内存分配图如下： 
 
 
垃圾：指的是在程序开发之中没有任何对象所指向的一块堆内存空间，这块空间就成为垃圾，所有的垃圾将等待GC（垃圾收集器）不定期的进行回收与空间的释放。
 
未完待续。。。

通过学习视频，特意写下此次博客。本次博客目的是为了理解面向对象的思想，掌握面向对象的基本原则以及 Java 面向对象编程基本实现原理，熟练使用封装、继承、多态面向对象三大特性。仅是博主本人总结，可能会有很多不足之处，希望读者可以有目的的阅读。
 
一、类和对象
 
1.面向对象
 （1）面向对象的理解
 
面向对象是已对象为基础，完成各种操作主要强调对象。
 
（2）面向对象的特点
 
面向对象是一种常见的思想，比较符合人们的思考习惯；
面向对象可以将复杂的业务逻辑简单化，增强代码复用性；
面向对象具有抽象、封装、继承、多态等特性。
 
2.类和对象
 （1）类：即模子，确定对象将会拥有的特征（属性）和行为（方法）。
 （2）类的特点：类是对象的类型，是具有相同属性和方法的一组对象的集合。
 （3）属性：对象具有的各种特征（每个对象的属性都拥有特定值）。
 （4）方法：对象执行的操作。
 （5）类和对象的关系：类是抽象的概念，仅仅是模板；对象是一个你能够看得到、摸得着的具体实体。
 
3.定义类
 
（1）定义类的步骤
 
a.定义类名
b.编写类的属性
c.编写类的方法
 
public class 类名{
			//定义属性部分（成员变量）
			属性1的类型 属性1；
			属性2的类型 属性2；
			...
			属性n的类型 属性n；
			//定义方法部分
			方法1；
			方法2；
			...
			方法m；
}
 
4.成员变量和局部变量区别
 （1）作用域不同
 
局部变量的作用域仅限于定义它的方法
成员变量的作用域在整个类内部都是可见的
 
（2）初始值不同
 
Java会给成员变量一个初始值，Java不会给局部变量赋予初始值。
 
（3）在同一个方法中,不允许有同名局部变量;在不同的方法中,可以有同名局部变量
 
（4）两类变量同名时,局部变量具有更高的优先级
 
5.构造方法：
 （1）使用new+构造方法创建-个新的对象
 （2）构造方法是定义在Java类中的一个用来初始化对象的方法，构造方法与类同名且没有返回值。
 （3）无参构造方法的使用
 
main():
Telphone phone = new Telphone0;
class Telphone:
	public Telphone() {
		System.out.println("Telphone构造方法执行了");
	}
 
（4）带参构造方法的使用
 

main():
Telphone phone2 = new Telphone(4.0f, 2.0f, 2.0f);
class Telphone:
	public Telphone(float newScreen,float newCpu,float newMem) {
		screen = newScreen;
		cpu = newCpu;
		mem = newMem;
}

 
（5）当没有指定构造方法时,系统会自动添加无参的构造方法。
 （6）当有指定构造方法,无论是有参、无参的构造方法，都不会自动添加无参的构造方法。
 （7）构造方法的重载:方法名相同,但参数不同的多个方法，调用时会自动根据不同的参数选择相应的方法。
 （8）构造方法不但可以给对象的属性赋值,还可以保证给对象的属性赋一一个合理的值。
 
构造方法的语句格式
没有返回值类型，与类名相同
public构造方法名(可以指定参数){
//初始化代码
}
 
6.static
 （1）静态变量
 
static修饰的成员被称为静态成员或类成员，它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享，静态成员可以使用类名直接访问，也可以使用对象名进行访问，更推荐类名访问；
 
语法：类名.静态变量名 或 对象.静态变量名
 
使用static可以修饰变量、方法和代码块；
静态成员属于整个类，当系统第一次使用该类时，就会为其分配内存空间，直到该类被缺载时才会进行资源回收。
 
（2）静态方法
 
静态方法可以直接调用同类中的静态成员，但不能直接调用非静态成员。如果想调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量；
 
语法：类名 对象名=new 类名();System.out.println(对象名.非静态变量名);
 
在普通成员方法中，则可以直接访问同类的非静态变量和静态变量；
静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。
 
（3）静态初始化块
 
在类的声明中，可以包含多个初始化块（用{}包含），当创建类的实例时，就会依次执行这些代码块。如果使用static修饰代码块，就称为静态初始化块；
静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的变量成员；
 
语法：static{};
 
程序运行时，静态初始化块最先被执行，然后执行普通的初始化块，最后才执行构造方法。
 
二、 封装
 
1.封装
 （1）概念:
 将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问
 （2）好处:
 
a.只能通过规定的方法访问数据
b.隐藏类的实例细节,方便修改和实现
 
（3）封装的实现步骤
 
 2.使用包管理Java中的类
 
1.Java中的包
 （1）包的作用:
 
管理Java文件
解决同名文件冲突
 
（2）定义包: package包名
 注:必须放在Java源程序的第一行，包名间可以使用"."号隔开eg:com.imooc.MyClass。
 例如:音乐类一-MyClassMusic
 
-music
  com.imooc.music.MyClassMusic
  
-movie
  com.imooc.movie.MyClassMusic
 
3.系统中的包
 
java.（功能）.（类）
java.lang.（类）包含java语言基础的类
java.util.（类）包含java语言中的各种工具类
java.io.（类）包含输入、输出相关功能的类
 
4.包的使用
 ( 1 )可以通过import关键字,在某个文件使用其它文件中的类.
 import com.imooc.music.MyClass
 ( 2 ) Java中,包的命名规范是全小写字母拼写
 ( 3 )使用的时候不但可以加载某个包下的所有文件
 eg: com.imooc.*
 也可以加载某个具体子包下的所有文件eg:com.imooc.music.*
 
5.Java中访问控制符
 （1）四种访问控制符的权限大小(由大到小)为public(公共)、protected(保护)、default(默认)、 private(私有)。
 
private(私有)：当类中属性或方法被private修饰时，表示此成员或方法只能被自己类中的方法使用，而不能被外部类或对象直接使用。
default(默认)：具有包访问权限，如果类中属性或方法不使用public,protected,privete修饰符修饰时，则说明其具有包访问权限，具有包访问权限的属性或方法既可以被自己类中的方法使用也可以被同一包下的其他类使用，但不能被其他包中的类使用。
protected(保护)：具有子类访问权限。如果类中属性或方法被protected修饰符修饰，则此类中属性或方法可以被同一包下的类使用，也可以被不同包下的子类使用，但不能被不同包下的其他类使用。例如：
public(公共)：具有公共访问权限。如果类中的属性或方法被public修饰，则此类中的属性或方法可以被任何类调用。
 
6.Java中this关键字
 （1）this关键字的主要三个应用
 
this调用本类中的属性，也就是类中的成员变量；
this调用本类中的其他方法；
this调用本类中的其他构造方法，调用时要放在构造方法的首行。
 
注意：系统自动生成set和get方法；
 
 7.Java中的内部类
 （1）概念：
 
内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。
 
（2）作用：
 
 
内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
 
 
内部类的方法可以直接访问外部类的所有数据，包括私有的数据
 
 
内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便
 
 
（3）好处
 
实现多重继承。
内部类可以很好的实现隐藏：一般的非内部类，是不允许有 private 与protected权限的，但内部类可以。
减少了类文件编译后的产生的字节码文件的大小。
 （4）缺点
使程序结构不清楚。
 
8.成员内部类
 （1）概念
 
成员内部类也叫实例内部类。应用场合：每一个外部类对象都需要一个内部类的实例，内部类离不开外部类存在（相当于心脏对人体）。
 
（2）成员内部类的特征：
 
作为外部类的一个成员存在，与外部类的属性、方法并列
成员内部类持有外部类的引用
成员内部类中不能定义static变量和方法
 
（3）使用格式
 
//外部类0uter
public class Outer {
private int a = 99; //外部类的私有属性//内部类Inner
public class Inner {
int b = 2;//内部类的成员属性public void test() {
System. out . println("访问外部类中的a:”+ a);System. out . println("访问内部类中的b:”+ b);

}
}
//测试成员内部类
public static void main(String[] args) {
Outer。= new outer();//创建外部类对象，对象名为o
Inner i = o.new Inner();// 使用外部类对象创建内部类对象，对象名为ii.test();//调用内部类对象的test方法

}

 
注意：外部类是不能直接使用内部类的成员和方法滴
 
//外部类HelloWorld
    public class HelloWorld {
      public class Inner {
      //内部类的方法
      public void show() {
      System. out . printIn("welcome to imooc !");
}
}
   public void print() {
      show(); 		//外部类调用内部类的成员方法，外部类不能直接访问内部类中的成员方法
	}
}
 
注意：可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。
 （4） 如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。如：
 
//外部类Outer
public class Outer {
int b = 1;//外部类中的成员属性b
//内部类Inner
public class Inner {
int b = 2; 	//内部类的成员属性b
public void test() {
System. out . println("访问外部类中的b：" + Outer. this.b);
System. out . println("访问内部类中的b: " + b);

}
}
 
（5）创建内部类的对象
 需要先创建外部类的对象，然后外部类对象名.new 内部类();
 
//创建外部类的对象
Helloworld 0 = new Helloworld ();//创建内部类的对象
Inner inn = o. new Inner()

 
9.静态内部类
 （1）内部类如果使用static声明，则此内部类就称为静态内部类。（其实也相当于外部类）可以通过外部类 . 内部类来访问。
 
（2）静态内部类使用场合：内部类不需要外部类的实例（注意区分成员内部类），静态内部类存在仅仅为外部类提供服务或者逻辑上属于外部类，且逻辑上可以单独存在。
 
（3）静态内部类的特征：
 
静态内部类不会持有外部类的引用
静态内部类可以访问外部的静态变量，如果访问外部类的成员变量必须通过外部类的实例访问
 
（4）Java中只有内部类才可以是静态的
 10.局部内部类
 （1）局部内部类也叫区域内嵌类，局部内部类与成员内部类类似，不过，区域内嵌类是定义在一个方法中的内嵌类。
 （2）使用场合：如果内部类对象仅仅为外部类的某个方法使用，使用局部内部类
 （3）特征：
 
用在方法内部，作用范围仅限于该方法中
根据情况决定持有外部类对象引用
不能使用private，protected，public修饰符
不能包含静态成员
 
11.匿名内部类
 （1）如果一个内部类在整个操作中只使用一次的话，就可以定义为匿名内部类。匿名内部类也就是没有名字的内部类，这是java为了方便我们编写程序而设计的一个机制，因为有时候有的内部类只需要创建一个它的对象就可以了，以后再不会用到这个类，这时候使用匿名内部类就比较合适。
 （2）使用场合：简化内部类的使用
 （3）特征：
 
使用new创建 ，没有具体位置
创建的匿名类，默认继承或实现new后面的类型
根据使用情况决定是否持有外部类对象引用
内嵌匿名类编译后生成的.class文件的命名方式是”外部类名称$编号.class”，编号为1，2，3…n，编号为x的文件对应的就是第x个匿名类
 
三、继承
 
1.重写
 （1）什么是方法的重写:
 
如果子类对继承父类的方法不满意,是可以重写父类继承的方法的，当调用方法时会优先调用子类的方法。
 
（2）语法规则:
 
a.返回值类型
b.方法名
c.参数类型及个数
 
注意：都要与父类继承的方法相同,才叫方法的重写。
 
2.继承的初始化顺序
 （1）初始化父类再初始子类
 （2）先执行初始化对象中属性,再执行构造方法中的初始化
 注意：Java中是单继承的。
 3.final关键字
 
（1）使用final关键字做标识有”最终的”含义。
 
（2）final可以修饰类、方法、属性和变量
 
final修饰类,则该类不允许被继承
final修饰方法,则该方法不允许被覆盖(重写)
fina|修饰属性
 
注意：则该类的属性不会进行隐式的初始化(类的初始化属性必须有值)或在构造方法中赋值(但只能选其一)
 
（3）final修饰变量,则该变量的值只能赋一次值,即变为常量
 4.super关键字:
 在对象的内部使用,可以代表父类对象。
 （1）访问父类的属性
 
super.age
 
（2）访问父类的方法
 
super.eat()
 
注意：通过super()关键字调用父类无参的构造方法，但是必须放到第一行。
 （3）子类的构造的过程当中必须调用其父类的构造方法。
 
如果子类的构造方法中没有显示调用父类的构造方法,则系统系默认调用父类无参的构造方法。
如果显示的调用构造方法,必须在子类的构造方法的第一行。
如果子类构造方法中既没有显式调用父类的构造方法,而父类又没有无参的构造方法,则编译出错。
 
5.Object类
 默认的是所有类的父类，其类中的方法如下：
 （1） toString ( )方法
 
在Object类里面定义toString ( )方法的时候返回的对象的哈希code码(对象地址字符串)
可以通过重写toString ( ) 方法表示出对象的属性
 
注意：重写toString方法，不用自己写，直接source中选
 （2）equals( )方法
 
比较的是对象的引用是否指向同一块内存地址。Dog dog = new Dog()
一般情况下比较两个对象时比较他的值是否一 致,所以要进行重写。
 
四、多态
 
1.概念：
 
允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。
 
2.创建父类对象，也可以引用父类创建子类对象
 
Animal obj1 = new Animal);
Animal obj2 = new Dog0;//父类的引用是可以指向子类对象的

 
3.多态的分类：
 （1）引用多态
 
父类的引用可以指向本类的对象父类的引用可以指向子类的对象
 
（2）方法多态
 
创建本类对象时,调用的方法为本类方法
创建子类对象时,调用的方法为子类重写的方法或者继承的方法
 
4.引用类型转换
 （1）向上类型转换(隐式/自动类型转换) ,是小类型到
 大类型的转换
 （2）向下类型转换(强制类型转换) ,是大类型到小类型3. instanceof运算符,来解决引用对象的类型,避免类型转换的安全性问题
 
  Dog dog = new Dog0;

      Animal animal = dog://向上类型转换自动类型转换
      if(animal instanceof Dog){
     	 	 Dog dog2 = (Dog)animal;
     	 }else{
     		 System.outprintIn("无法进行类型转换);
      }
      if(animal instanceof Cat){
			Cat cat = (Cat)animal://1.编译时Cat类型2.运行时Dog类型
	  }else{
  			System.outprintIn(无法进行类型转换");
     }

 
5.抽象类
 （1）概念：
 
抽象类前使用abstract关键字修饰,则该类为抽象类。
 
（2）应用场景:
 
在某些情况下,某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。
从多个具有相同特征的类中抽象出一个抽象类,以这个抽象类 作为子类的模板,从而避免了子类设计的随意性。
 
（3）作用:
 限制规定子类必须实现某些方法,但不关注实现细节
 （4）使用规则
 
abstract定义抽象类
abstract定义抽象方法,只有声明,不需要实现
包含抽象方法的类是抽象类
抽象类中可以包含普通的方法,也可以没有抽象方法e.抽象类不能直接创建,可以定义引用变量
 
6.接口
 （1）接口概念
 
接口可以理解为一种特殊的类,由全局常量和公共的抽象方法所组成。
 
（2）接口定义
 
和类定义不同,定义接口不再使用class关键字,而是使用interface关键字。
 
接口定义的基本语法:
[修饰符]jinterface 接口名[extends父接口1,父接口...]
{
零个到多个常量定义...
零个到多个抽象方法的定义...
}
 
注意：接口就是用来被继承、被实现的,修饰符一般建议用public注意:不能使用private和protected修饰接口
 
（3）接口定义
 
常量:
 
接口中的属性是常量,即使定义时不添加public static final修饰符,系统也会自动加上。
 
方法:
 
接口中的方法只能是抽象方法,总是使用,即使定义时不添加public abstract修饰符,系统也会自动加上。
 （4）使用接口
 
一个类可以实现一个或多个接口,实现接口使用implements关键字。Java中一个类只能继承一个父类,是不够灵活的通过实现多个接口可以做补充。
继承父类实现接口的语法为:
 
[修饰符] class类名extends父类implements接口1 ,接口2...
{
类体部分//如果继承了抽象类,需要实现继承的抽象方法;要实现接口中的抽象方法。
}
 
注意：如果要继承父类,继承父类必须在实现接口之前
 
（5）使用接口:
 
接口在使用过程当中，还经常与匿名内部类配合使用 匿名内部类就是没有名字的内部类,多用于关注实现而不关注实现类的名称。
 
语法格式:
Interface i= new Interface(){
	public void method() {
		System.out.println("匿名内部类实现接口的方式");
		}
};
 
为了更好的理解类和对象，做了答答租车系统的项目练习，具体的代码，以及实现过程，附上博客地址：
 
https://blog.csdn.net/qs17809259715/article/details/89297448

C++类和对象数组
 
【1】对象数组
 
1：对象数组的定义：类名 数组名[元素个数]
 
Eg: student asa[10];//有10个元素的学生类对象数组
 
2：对象数组的访问形式：数组名[下标].成员名；
 
Eg: asa[j].print();
 
3:对象数组的初始化：对象数组的初始化通常也是由构造函数来完成的。
 
Eg: #include”student.h”
 
int main
 
{
 
student asa[4]={student（1，“LiMing”,98）,student(2,”Bill”,89),student(3,”Chlily”,99),student(4,”Saraea”,96)};
 
for(int i=0;i<4;i++)
 
asa[i].print();
 
return 0;
 
}
 
【2】指向对象的指针
 
1：对象指针的用法：定义对象指针的语法和定义其它基本数据类型指针的语法相同。在使用对象指针之前，要把它指向一个已经创建的对象，然后才能访问该对象的成员。在使用对象名来访问对象成员时，要使用点运算符“.”。如果要通过指向对象的指针来访问对象的成员，那么必须使用箭头运算符“->”。
 
【3】this指针
 
    Eg: class student
 
{
 
    int number;
 
    char name[15];
 
    float score;
 
    void display()
 
{
 
    cout<<”number: ”<<number;
 
cout<<”name: ”<<name;
 
cout<<”score: ”<<score;<<endl;
 
}
 
};
 
1：在成员函数display（）中有一个隐藏的指针作为参数，该指针参数使用关键字this命名，它是指向该类对象的指针，成员函数可以通过它来访问该类对象的数据成员。voiddisplay(student *this)//this指针由编译器自动生成。
 
2：this指针是由C++编译器自动产生的一个隐含指针，编译器将该指针自动插入到类的所有成员函数的参数列表中，成员函数使用该指针来存取对象的数据成员。
 
3：内存中只有一份成员函数的备份，而且对象的实例变量和成员函数是分开存放的，eg：X const *this。当对象调用该函数时，编译器自动将该对象的地址作为实参传递给相应的成员函数的this指针。
 
Eg:void date::set(date* constthis,int d,int m,int y)
 
{
 
    this->day=d;
 
    this->month=m;
 
    this->year=y;
 
}
 
注意：this指针由编译器自动生成，程序员不能将this指针的说明写在函数中，否则将出现编译时间错误信息。
 
4：this指针是系统的一个内部指针，通常以隐式方式使用，但也可以被程序员显式使用，例如，当运算符重载和建立双向链表时，显式使用this指针十分必要。
 
【4】对象的赋值：如果两个对象属于同一种类类型，换句话说，两个对象是由同一个类声明的，那么我们可以将其中的一个对象的值（属性值）赋给另一个对象。默认情况下，当将一个对象赋值给另一个对象时，第一个对象的数据将被按位复制到第二个对象中。对象的赋值仅仅是使两个对象的值相等，而这两个对象仍然是相互独立的，即修改一个对象的值将不会影响到另一个对象。
 
Eg:Rectangle rect1(10,20),rect2(0,0);
 
    rect2=rect1;
 
【5】对象作为函数参数：分类：传值调用，传址调用
 
    1：传值调用：传值调用，传送的是作为实际参数的对象的拷贝而不是实际对象的本身。因此在函数中改变对象的值不会影响作为实际参数对象本身。
 
    Class Square
 
{
 
        int side;
 
    public:
 
       void set(int x) {side=x;}
 
       void out() {cout<<side<<”\n”;}
 
};
 
void f(square x)
 
{
 
    x.out();
 
    x.set(100);
 
    x.out();
 
} 
 
    int main()
 
{
 
    Square s;
 
    s.set(10);
 
    f(s);
 
    s.out();
 
return 0;
 
}   
 
    2：传址调用：当函数调用时传递的是作为实际参数的对象的地址，就是传址调用方式。在函数中对作为形式参数的对象的修改实际上就是对作为实际参数的对象的修改。我们既可以使用对象的引用来实现传址调用，也可以用指针来实现。
 
使用对象的引用来实现传址调用：
 
Class Square
 
{
 
        int side;
 
    public:
 
       void set(int x){side=x;}
 
       void out() {cout<<side<<”\n”;}
 
};
 
void f(square &x)//对象的引用作为函数的参数
 
{
 
    x.out();
 
    x.set(100);
 
    x.out();
 
} 
 
    int main()
 
{
 
    Square s;
 
    s.set(10);
 
    f(s);
 
    s.out();
 
return 0;
 
}
 
使用指向对象的指针来实现传址调用的例子
 
Class Square
 
{
 
        int side;
 
    public:
 
       void set(int x){side=x;}
 
       void out() {cout<<side<<”\n”;}
 
};
 
void f(square *x)
 
{
 
    x.out();
 
    x.set(100);
 
    x.out();
 
} 
 
    int main()
 
{
 
    Square s;
 
    s.set(10);
 
    f(&s);
 
    s.out();
 
return 0;
 
}
 
【6】从函数返回对象：当函数返回对象时，函数创建了一个临时对象来保存要返回的值，而函数所返回的对象实际上是这个临时对象。在对象的值被返回之后，临时对象将被销毁。
 
    Eg:mystring input()
 
{
 
    char instr[80];
 
    mystring str;
 
   cin>>instr;
 
str.set(instr);
 
return str;//返回一个mystring对象
 
}
 
int main()
 
{
 
    Mystring ob;
 
    ob=.input();
 
    ob.print()；
 
    return 0；
 
}
 
【7】类的静态成员
 
1：静态成员：C中通过在变量定义的前面加static关键字就可以将变量声明为静态变量。采用局部静态变量可以减少全局变量的使用：将全局变量声明为静态的可以降低全局变量的副作用。C++中通过在类的成员函数前面加上static关键字将其成员声明为静态成员，一个类的静态成员既可以是静态数据成员，也可以是静态成员函数。
 
 
静态数据成员
 
声明类的静态数据成员的方式是在变量定义的前面加static关键字
 
classstudent
 
{
 
  private:
 
      int num;
 
      char *name;
 
      float score;
 
      static int count;
 
      static float sum;//类student的静态数据成员的声明
 
  public:
 
      ……
 
};
 
intstudent::count=0;
 
floatstudent::sum=0; //静态成员变量应在创建类的对象前定义并进行初始化
 
一个类的静态数据成员为该类的所有对象所共有，不管创造了这个类的多少个对象，其静态数据成员在内存中只有一份拷贝。由于只有一个类的静态成员只有一份拷贝，所以我们经常使用“类名：：”来访问静态数据成员。例如：counter：：count=0；
 
    静态成员变量的最一般的作用就是对一些共享资源提供存取控制。
 
静态成员好处就是减少了全局变量的使用。
 
静态成员主要作用就是定义类的各个对象所共用的数据，如统计总数，平均数等。
 
 2：静态成员函数：在类的成员函数前面加上static关键字说明的函数就是静态成员函数。只使用静态数据成员的函数可以定义为静态成员函数。对静态成员函数的引用使用所属的类名加作用域分辨运算符来限制，即“类名：：”。
 
Eg: classStudent
 
{
 
    private:
 
       ……
 
    public:
 
static void init()
 
{
 
               Student::count=0;
 
              Student::sum=0;
 
}
 
Static float average();
 
};
 
float student::average()
 
{
 
    cout<<”sum is ”<<sum<<“\tcount is ”<<count<<endl;
 
    cout<<”average is”<<sum/count<<endl;
 
    return sum/count;
 
}
 
静态成员函数可以在创建该类的任何成员之前处理静态数据成员，这是普通成员函数不能实现的。一般来说，类的静态成员函数是用来访问静态数据成员的，当然可以访问全局变量。静态成员函数不具有this指针。也就是说，静态成员函数不与某个具体的对象相联系，它只属于该类。
 
【8】类的友元
 
1：友元函数：将关键字friend放在函数名的前面就将该函数说明为友元函数。一个类的友元函数是在该类中说明的一个非成员函数，但允许访问该类对象的所有成员。友元函数可以访问类的私有成员，节省了调用成员函数的开销，从而提高了程序的运行效率。如果需要一个函数同时访问多个类，则它可以定义为多个类的友元函数。1)使用友元破坏了封装性，降低了程序的可维护性。因此使用友元时要慎重的权衡得失后再决定。2)因为友元函数不是类的成员，故在友元函数中没有this指针，因此必须通过函数参数来传递对象。
 
2：友元类：若一个类为另一个类的友元，则次类的所有成员函数都能访问对方类的私有成员。下例所示：类B的所有成员函数都是类A的友元函数，都能够访问类A的所有成员。但是类A不是类B的友元类
 
Eg:class A
 
{
 
    ……
 
public:
 
    friend class B;
 
    ……
 
};
 
 

对象在需求中的使用

在具体问题中如何使用面向对象去分析问题，和如何使用面向对象。

以把大象装冰箱为例进行分析：
在针对具体的需求，可以使用名词提炼的办法进行分析，寻找具体的对象。


需求：把大象装冰箱里


对象：大象、冰箱

分三步：

    1、打开冰箱门

    2、将大象装进去

    3、关闭冰箱门

分析发现打开、装、关闭都是冰箱的功能。即冰箱对象具备如下功能：

    1）冰箱打开

    2）冰箱存储

    3）冰箱关闭

用伪代码描述，上述需求中有两个具体的事物 大象 和  冰箱


描述大象：

    class 大象

        {

        }


描述冰箱

    class冰箱

        {

            void 打开(){}

            void 存储(大象){}

            void 关闭(){}

        }

当把具体的事物描述清楚之后，需要使用这些具体的事物，Java使用具体的事物，需要通过new关键字来创建这个事物的具体实例。


使用对象：

    1、创建冰箱的对象

        冰箱 bx = new 冰箱();  

    2、调用冰箱的功能

        对象.功能()；

        bx.打开();

        bx.存储(new 大象());

        bx.关闭();


总结：

1、先按照名词提炼问题领域中的对象

2、对对象进行描述，其实就是在明确对象中应该具备的属性和功能

3、通过new的方式就可以创建该事物的具体对象

4、通过该对象调用它以后的功能。


对象在代码中的体现

在分析现实生活中的事物时发现，这些事物都有其具体的特点和功能，这些特点和功能就组成了这个特殊的事物。
描述小汽车。
分析：
事物的特点（属性）：
 颜色。
 轮胎个数。
事物的(功能)：
 运行。

发现：事物其实就是由特点（属性）和行为（功能）组成的。
可以简单理解：属性就是数值，其实就是变量；行为就是功能，就是方法。
小汽车 {
 颜色；
 轮胎个数；
 运行() { }
}
通过计算机语言Java来描述这个事物。

定义类的格式

public class 类名 {
	//可编写0至n个属性
    数据类型 变量名1；
    数据类型 变量名2；
	
	//可编写0至n个方法
	修饰符 返回值类型 方法名(参数){
		执行语句;
}
}

汽车类
public class Car {
	String color;
	int number;

	void run() {
		System.out.println(color + ":" + number);
	}
}
通过代码的描述，知道类的真正意义就是在描述事物。属性和功能统称为事物中的成员。

事物的成员分为两种：成员属性和成员功能。

成员属性在代码中的体现就是成员变量

成员功能在代码中的体现就是成员方法


把写好的代码测试一下。需要一个可以独立运行类。
创建对象的格式：

类名 对象名 = new 类名();

测试类

public class CarDemo {
	public static void main(String[] args) { 
		/*
		 *  测试：Car类中的run方法。
		 */
		// 1,创建Car的对象。给对象起个名字。
		Car c = new Car();// c是类类型的变量。c指向了一个具体的Car类型的对象。
		// 2,通过已有的对象调用该对象的功能。格式：对象.对象成员;
		// 3,可以该对象的属性赋值。
		c.color = "red";
		c.number = 4;
		c.run();
	}
}

类和对象的区别
面向对象的编程思想力图在程序中对事物的描述与该事物在现实中的形态保持一致。为了做到这一点，面向对象的思想中提出两个概念，即类和对象。其中，类是对某一类事物的抽象描述，而对象用于表示现实中该类事物的个体。接下来通过一个图例来抽象描述类与对象的关系，如下图所示。




在上图中，可以将玩具模型看作是一个类，将一个个玩具看作对象，从玩具模型和玩具之间的关系便可以看出类与对象之间的关系。类用于描述多个对象的共同特征，它是对象的模板。对象用于描述现实中的个体，它是类的实例。从上图中可以明显看出对象是根据类创建的，并且一个类可以对应多个对象，接下来分别讲解什么是类和对象。
经过前面几个知识点的学习，基本上掌握了类是用于描述事物的，类中可以定义事物的属性和行为。而对象是通过描述的这个类，使用new关键字创建出来，通过对象就可以调用该对象具体的属性和功能了。


局部变量和成员变量区别

理解清楚了类和对象之后，发现在描述类的属性定义变量差别不大，唯一区别就是位置发生了改变，那么类中定义的变量，和在方法定义的变量有什么差别呢？总结下面几点异同
区别一：定义的位置不同
    定义在类中的变量是成员变量
    定义在方法中或者{}语句里面的变量是局部变量
区别二：在内存中的位置不同
    成员变量存储在对内存的对象中
    局部变量存储在栈内存的方法中
区别三：声明周期不同
    成员变量随着对象的出现而出现在堆中，随着对象的消失而从堆中消失
    局部变量随着方法的运行而出现在栈中，随着方法的弹栈而消失
区别四：初始化不同
    成员变量因为在堆内存中，所有默认的初始化值

    局部变量没有默认的初始化值，必须手动的给其赋值才可以使用。
本文结。