黑马程序员——java学习之面向对象的三大体系

        ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

            经过两三天的学习，重温了java面向对象的知识，加深了对面向对象的理解，同时也为下一步的学校做好了准备，但是总体来说，还是有所薄弱的地方，譬如静态这块。下面是我的学习笔记，针对视频内容加上了需要自己特别注意的地方。

    面向对象的特点：找对象，建立对象，使用对象，维护对象的关系。

    类与对象的关系：类就是对现实生活中事物的描述  对象就是这类事物实际存在的个体。  具体new操作出建立在堆中的实体。      描述就是class定义的类。就是定义事物的属性和行为。例如定义汽车类；属性与行为成为类中的成员，比如颜色，汽车运动。

    建立好对象，就可以在堆内存中new出对象。new类名（）。

    Car c =new Car（）c是一个类类型变量。变量指向对象。栈内存中出现一个变量c，堆内存中有一个对象实体。

    java中的指挥方式：对象.对象成员（包括属性及行为）

    成员变量与局部变量：成员变量作用于整个类中，局部变量作用于函数中。（作用范围）（内存位置不同）成员变量在堆内存中，局部变量存在于栈内存中。  注意：可以在类中独立运行主函数。

    匿名对象使用方式：1，当对对现象的方法只掉用一次，这样可以简化，但是不可以调用多个成员。2，可以将匿名对象作为实际参数进行传递

java面向对象的特性一、

    封装：隐藏对象的属性和实现细节，进对外提供公共的访问方式。

    private只在本类有效，可以修饰类中的成员：成员变量，成员函数。

    一个成员变量通常会对应两个方法，一个set，一个get。

    构造函数；名字固定，与类名相同，不需要定义返回值类型，同样也不需要return返回值。

构造函数示例：

class Person{

Person（）{}

}

   构造函数中，对象一建立，就会调用构造函数，它的作用是可以对对象进行初始化。

   构造代码块与构造函数区别：构造代码块是个所有对象进行初始化     构造函数是给指定的对象初始化。

   构造函数间调用要用this（参数值）。

面向对象中的静态：

   static关键字：用于修饰成员，包括成员变量和成员函数。被修饰后不在堆内存中，静态修饰内容被对象所共享，节省堆内存的资源。

   被静态修饰的成员多了一种调用方法，可以直接被类名调用。方式为：类名.静态成员。

   内存中的方法区：数据区，共享区。

   static特点：1，生命周期长，随着类的加载而存在于方法区中2，优于对象存在。3，被对象所共享。4，可以直接被类名调用。

   静态的成员变量称之为类变量。一般的成员变量为实例变量。

   注意事项：1，静态方法只能访问静态成员。2，静态方法中不可以出现this，super关键字。因为静态优先于对象存在。

   有趣的是：jvm虚拟机调用主函数时，传入的是一个数组。new String[0]；

   另外工具类一般都是静态的成员。方便主函数或者其它类的调用。直接调用类名.成员函数名就可以。不需要建立对象。这样更为严谨。

静态代码块的特点：随着类的加载而执行，只执行一次。并优先于主函数调用，没名字。

   设计模式：java中有23个设计模式  纯偏思想的。

   单例设计模式：解决一个类在一个内存中只有一个对象。

   想要保证对象唯一：1，为了其他程序过多建立该类对象，先控制禁止其它程序建立对象。

                     2，为了让其它程序能访问到该类对象，在被类中自定义一个对象。

                     3，对外提供访问方式。

代码实现：1，将构造函数私有化。2，在类中创建一个本类静态对象并私有化。3，提供私有化静态方法。

能被类名调用的方法，一定是私有的。

    对于事物该怎么描述还怎么描述，只需要保证该事物的对象在内存中唯一，就需要加上单例模式的3步骤。

单例模式方式二：后初始化对象，在方法中创建对象，是延迟加载的称为懒汉式。要判断是否为空。前者称为饿汉式。

区别：饿汉式，single类一进内存，对象便建立了。懒汉式只有在调用了方法式才建立对象，也成为延迟加载。

          一般开发使用饿汉式，安全。懒汉式会导致线程的问题。

同步：synchronized，锁，解决懒汉式线程的问题。效率会变低。

下面是我写的单列模式的代码，这块很重要。另外代码部分没有加入主函数的调用。

饿汉式：

class Single
{
private static Single s = new Single();
private Single(){}
public static Single getInstance()
{
return s;
}
}

懒汉式：

class Single
{
	private static Single s = null;
	private Single(){}
	public static Single getInstance()
	{
		if(s==null)
		{
			synchronized(Single.class)
			{				
				if(s==null)
					s = new Single();
			}
		}
		return s;
	}
}

java面向对象的特性二、

   继承：关键字：extends   子继承父，父类有子类的共性特点，是子类不断抽取出来的。

   好处：提高代码复用性，继承让类与类之间产生关系，从而有了多态的特性。继承关系是is a的关系。

   注意：java中支持单继承，不支持多继承。java支持多层继承（继承体系）。

   另外，简单一句话，查阅父类功能，创建子类对象使用功能。

   继承中有super关键字。父类引用指向子类对象。是多态的特性。

   子类引用方法时覆盖父类的方法，叫做覆盖，重写。

   final关键字：可以修饰函数，类，变量。被final修饰的类不可以被继承。被final修饰的方法不可以被 复写。被final修饰的变量之只能被修饰一次。

   针对继承的特性要学会应用是重要的。所以这块要认真思考。

   在继承中需要注意：常量的书写规范所有字母都要大写，多个单词组成用_链接。

   抽象的关键字：abstract  看不懂的方法，没主体。抽象方法要建立`在抽象类上。抽象类不可以用new创建对象，不能被调用胡主要是因为（没意义）。抽象方法不可以实例化，抽象abstract只能修饰方法，不能修饰变量。

   在继承中有接口：interface用于定义接口，是一个特殊类。

   接口的格式：常量，抽象方法。成员都有固定修饰符。常量：public static final   方法：public abstract

   implements关键字是类与接口的链接关键字。表示实现。类与类之间叫继承，用extends。一个类可以实现多接口。子类只有继承接口全部的抽象方法才可以被实例化。接口的主要特性是 功能扩展。接口之间可以实现多继承。类与类之间不支持多继承 。

java中面向对象的特性三、

   多态：事物存在的多种体现。

   多态的基本体现：父类的引用指向了自己的子类对象。

   多态的前提：类与类之间要有关系（继承，实现）

   同样需要注意多态的应用。

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

   多态的转型：父类引用强制转换成子类类型。 Animal a= new Cat（） Cat c =（Cat）a   始终都是子类对象做变化。猫一会是动物，一会是猫。 instanceof所属类型判断关键字。 多态中静态方法调用走父类的。

   内部类：内部类指的是内部嵌套，类内还有一个类。

   特点：内部类可以访问外部类的私有成员。外部类要向访问内部类，要先建立内部类对象。

   格式：外部类名.内部类名  Outer.Inner in = new Outer().new Inner()

   内部类成员如何访问外部类成员。Outer.this.x   内部类中持有外部类的引用，该引用的写法是外部类名.this。

   注意：内部类可以被静态修饰，也可以被private修饰。内部类静态成员只能访问外部类的静态成员。

   当内部类中定义了静态成员，该内部类必须是静态的。

   静态的可以直接访问：Outer.method()。  

   外部类静态方法无法访问内部内非静态方法：因为外部类静态方法优先于内部类存在。  

   局部内部类不能有静态方法，因为这样会导致内部类也会是静态的。

   局部内部类中不可以被成员修饰符修饰，可以直接访问外部类中的成员，但是不可以访问局部中的变量，要想访问，局部变量要被final修饰。

   匿名内部类：内部类没名字，那么问题是如何给内部类new对象。  所以内部类就要继承一个其它外部类或者实现一个接口。

   抽象类不能new对象。所以要向创建一个匿名类 。   只能new 继承类名（）{复写继承类的抽象方法}。  这是new一个对象

调用方法时要在在后面再加上.方法。 匿名内部类方法不宜过多。为了简化而存在。

   今天看了一集日剧，主人公的一句话非常振奋人心，拿出来分享，也用于激励自己：既然是确认的事情，就要从心底里爱！！