黑马程序员__面向对象

----------- android培训、 java培训、java学习型技术博客、期待与您交流！ ------------

面向对象
  面向对象是相对面向过程而言的，面向对象和面向过程都是一种思想。面向过程强调的是功能行为，面向对象是将功能封装进对象，强调具备了功能的对象。面向对象是基于面向过程的。

面向对象使我们的角色发生了改变，由原来的执行者变为指挥者。

面向对象三个特征：封装、继承、多态。

面向对象开发
  1.找对象，名词提取法。
  2.建立对象
  3.使用对象
  4.维护对象的关系。

类和对象的关系
类：就是对现实生活中一类事物的描述，具有共性事物的抽象。
对象：就是生活中实际存在的事物的实体。
实体：用来存储多个数据，存在于堆内存中。

创建对象
new操作符用来创建对象。其实就是在堆内存中生成一个实体。
例如

class Person
{
	
}
class Test
{
	public static void main(String[] args)
	{
		//用new操作符创建一个对象
		Person p = new Person();
	}
}

匿名对象
当对象成员只调用一次时，用匿名对象比较简化，如果对对象成员多次调用时必须定义引用，因为每次new都会生成一个对象。
总结：简化的表达式都有局限性。

引用：强引用、弱引用、软引用、虚引用。在以后的学习中都与遇到。

成员变量
成员变量值都有默认值，因为在堆内存中，堆内存中的变量都有默认值。

封装（Encapsulation）
封装是指隐藏对象属性和实现，仅对外提供公共访问方式。
封装的好处：
1.将变化隔离
2.便于利用
3.提高复用性
4.提高安全性
封装原则：
1.将不需要对外提供的内容隐藏起来
2.把属性都隐藏，提供公共方法访问

权限修饰符
public：权限修饰符，类以外的对象都可以访问。

private：权限修饰符，用于修饰类中的成员,私有是封装的一种形式。
private修饰后，类以外对象无法访问，需要提供相应的访问方式。可以在访问方式中加入逻辑判断等语句，对访问的数据进行操作，提高了代码健壮性。

构造函数
构造函数特点：
1.与类名相同
2.不用定义返回值
3.不可以写return语句
构造函数的作用：对对象进行初始化。
注意：
1.默认构造函数的特点
2.多个构造函数是以重载的形式存在的
不写构造函数式，系统会创建默认不带参数的构造函数。如果写了带参数的构造函数而没有手动创建不带参数的构造函数时，调用不带参数的构造函数会报错。
构造函数与一般函数的区别：
1.写法不同
2.运行不同
  构造函数只执行一次，一般函数可执行多次。
  构造函数在对象已建立就运行，一般函数调用才执行。

构造代码块
只有两个大括号的区间，优先构造函数执行。
与构造函数的区别：
对所有对象进行统一初始化而构造函数是给对应对象进行初始化。
总结：将所有对象共性属性在构造代码块中初始化。

this关键字

public class Person
{
	private String name;
	Person(String name)
	{
		this.name = name;
	}
}

当局部变量名与成员变量名相同时，成员变量需要用this关键字标识。
this关键字代表它所在函数所属对象的引用。
this的应用：
当定义类中功能时，该函数内部要用到调用函数的对象时，这时用this来标识这个对象。
this关键字在构造函数间调用：

class Person
{
	private String name;
	private int age;
	Person(String name)
	{
		this.name = name;
	}

	Peron(String name,int age)
	{
		this(name);
		this.age = age;//注意不可以直接Person(name)调用构造函数
	}
}

构造函数间调用只能用this语句。
注意：
this语句中只能定义在构造函数第一行（super也是这样），因为初始化动作先执行。
构造函数不允许互相调用会发生死循环。

static（静态）
static表示静态对象共享属性，非静态的属性是对象特有属性。

public class Person
{
	//静态成员变量
	public static String name;
	//静态函数
	public static void method()
	{
		System.out.println("this is a method");
	}
}

1.存放位置：
  静态变量随着类的加载而加载，存在于方法区内存中。
  实例变量随着对象的简历而存在于堆内存中
2.生命周期：
  类变量生命周期最长，随着类的消失而消失。
  实例变量生命周期随着对象的消失而消失。

静态代码块

public class Person
{
	//静态代码块
	static 
	{
		......
	}
}

特点：
随着类的加载而执行，只执行一次，优先于主函数以及其他函数，用于给类进行初始化（如果不需要对象如工具类）。
类加载：只要访问类成员类就会被加载。

public class StaticCode
{
	//静态代码块a
	static 
	{
		System.out.println("the static code a");
	}
}
class StaticCodeDemo
{
	//静态代码块b
	static
	{
		System.out.println("the static code b");
	}
	public static void main(String[] args)
	{
		new StaticCode();//第一次会执行
		new StaticCode();//第二次不会执行，因为静态代码块只执行一次
		System.out.println("over");
	}
	//静态代码块c
	static
	{
		System.out.println("the static code c");
	}
}

注意：判断代码块执行顺序，从类加载到JVM执行main函数代码在内存中的执行顺序。
什么时候定义静态函数？
当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的。

静态使用注意：
1.静态方法只能访问静态成员。
2.非静态方法即可访问静态页可访问非静态。
3.静态方法中不可以定义this，super关键字。因为静态优先于对象存在所以静态方中 
   不可以出现this（它没有被初始化）。
静态的利弊：
  利：
    1.对对象的共享属性景象单独空间存储节省空间，没有必要每一个对象中都存储一份。
    2.可以直接被类名调用
  弊：
   1.生命周期过长
   2.访问成员有局限性（静态只能访问静态的原因）

静态的应用：工具类
每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装，以便复用。工具类中所有方法都是静态不需要创建对象，可以通过构造函数私有化强制改类不能创建对象。

class Tools
{
	private Tools(){}

	public static void method1(){}
	public static void method2(){}
	.......
}

对象初始化过程
1.new创建对象时，先找到clas文件加载到内存中。
2.执行类中的静态代码块如果有的话，对类进行初始化。
3.在堆内存中开辟空间，分配内存地址。
4。在对内存中建立对象的特有属性，并进行默认初始化。
5.对属性进行显示初始化
6.对对象进行构造代码块初始化。
7.对对象进行相应构造函数初始化
8.将内存地址赋值给栈内存中的引用变量

继承
具有所属关系的类之间产生的一种现象。
特点：
1.提高了代码的复用性
2.让类与类之间产生了关系，有了这个关系，才有了多态的特性。
注意：
千万不要为了获取其他类的功能，简化代码而继承。必须是类与类之间有所属关系才可以继承。所属关系“is a”。

class Person
{
	private String name;
	Person(String name)
	{
		System.out.println("带参构造函数");
		this.name = name;
	}
	public void setName(String name)
	{
		this.name=name;
	}

	public String getName()
	{
		return name;
	}
}

class Student extends Person
{
	Student(String name)
	{
		super(name);
	}
	public static void main(String[] args)
	{
		new Student("张三").setName("何竹冬");
	}

}
/*class Single
{
	private Single(){}//构造函数私有化不允许外部创建对象
	private static Single s= new Single();//提供唯一对象
	//获取对象
	public static Single getInstance()
	{
		return s;
	}
}

java只支持单继承，不支持多继承的原因？
因为多继承容易带来安全隐患，当多个父类中定义了相同功能，但功能内容不同时，子类对象不确定要运行哪一个。
java保留了这种机制用另一种体现形式来完成表示多实现。
java支持多层继承，也就是继承体系。

父类与子类中变量关系
子类继承父类后会拥有父类的成员，只不过有些成员不可见。
加载顺序：先加载父类成员后加载子类成员。
子父类中的变量：
如果子类中出现非私有的同名成员变量时，子类要访问本来变量用this，访问父类中的同名变量用super。

父类与子类中函数
当子类中出现和父类一模一样的函数（参数列表，返回值）时，当子类对象调用该函数，会运行子类函数的内容，如同父类被覆盖一样。这种情况是函数的另一种特性，重写（覆盖）。
覆盖：
1.子类覆盖父类，必须保证子类方法权限大于等于父类方法权限，才可以覆盖，否则编译失
   败。
2.静态只能覆盖静态。因为静态优先于对象存在。
3.如果子类方法与父类私有方法同名，无法重写但不会报错，是一个新方法。
重载
当一个类中出现方法名相同，参数列表不同的方法时，被称为重载。重载可以改变返回值，因为它只看参数列表和名称。

子类的实例化过程
子父类中构造函数：
在对子类对象进行初始化时，父类默认构造函数会隐式执行。因为子类构造函数默认第一行有一条隐式语句super();会访问父类中的空参数的构造函数而且子类中所有构造函数的默认第一行都是suepr()；除非有this()或super调用带参数的构造函数，因为this和super在调用构造函数时都必须是在第一行。

final关键字final可以修饰属性，类，方法，表示属性不可变，类不能被继承，方法不能被重写。

抽象类
当多个类中出现相同功能，但功能主体不同。这时可以进行向上抽取。只抽取功能定义，不抽取功能主体时，用抽象类。
抽象类特点：
1.抽象方法一定在抽象类中
2.抽象方法和抽象类都必须被abstract关键字修饰
3.抽象类不可以用new创建对象，因为调用抽象方法没有意义。
4.抽象类中的抽象方法要被使用，必须由子类复写其所有抽象方法，建立子类对象调用。如
  果子类只复写了部分抽象方法，那么该子类还是一个抽象类。
抽象类特殊点：
1.抽象类比一般类多个抽象方法，不可以被实例化。
2.抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象
抽象类另一个作用是作为接口的适配器，实现接口的所有方法但方法体为空，由子类复写需要用到的接口中的方法。

接口（like a）
接口是一个特殊的抽象类。当类中的方法都是抽象方法时，可以通过接口的方式来表示，接口就是一种扩展。

接口的特点：
1.接口中常见定义：常量、抽象方法。
2。接口中成员都是固定修饰符，如果不写系统会自动默认添加。
   常量修饰符：public static final
   方法修饰符：public abstract
3.接口中成员都是public，由第二点可以得出。
4.不可以创建对象
5.可以被类多实现，也是对多继承不支持的转换形式，接口是不可以创建对象的，因为有抽
   象方法，需要被子类实现，子类对借口中的抽象方法全部覆盖后，子类才可以实例化（原
   因与抽象类一样），否则子类是一个抽象类。

接口与接口的关系：继承关系
接口可以多继承，因为没有方法体，不会出现安全问题。但是如果一个接口继承多个接口时，被继承的多个接口中有返回值不同的同名函数，调用函数时会出现问题。

接口的特点（好处）
1.接口是对外暴露的规则,接口是一种规范。
2.接口是程序的功能扩展（类似现实生活中的cpu插槽就是接口，不过这里是指程序中）
3.接口可以多实现
4.类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
5.接口与接口之间可以有继承关系

多态
某一种事物存在的多种体现形态。
多态自始至终都是子类对象在做着变化。
多态的体现：
1.父类的引用指向子类的对象（子类对象类型提升，自动向上转型）
2.父类的引用页可以接受自己的子类对象，（向下转型，需要强制类型转换）

多态的前提：必须是类与类之间有关系，要么继承，要么实现。
多态的好处：
1.多态大大提高了程序的扩展性
2.通常还有一个问题在覆盖

向上转型和向下转型

class Animal
{
}

class Cat extends Animal
{
}

class Test
{
	Animal animal = new Cat();//子类对象类型提升，自动向上转型
	Cat cat = (Cat)animal;//父类引用转换为子类类型，向下转型需要强制类型转换
}

内部类
将一个类定义在另一个类的里面，对里面那个类就成为内部类（内置类、嵌套类）。

class Body
{
	//内部类Foot
	class Foot
	{
		……
	}
}

内部类访问规则
1.内部类可以直接访问外部类成员，包括私有（内部类相当于外部类成员）之所以可以直接
   访问外部类中的成员，是因为内部类中持有一个外部类的引用，格式：外部类名.this
2。其他外部类要访问内部类，必须建立内部类对象。
内部类定义在局部时
1.不可以被成员修饰符修饰，如同其他局部变量一样
2.可以直接访问外部类中成员，因为还有外部类中的引用，但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。

匿名内部类
1.匿名内部类其实就是内部类的简写格式
2.定义匿名内部类前提：内部类必须是继承一个类或实现接口、
3.匿名内部类的格式：new 父类或接口名(){}
4.其实匿名内部类就是一个匿名子类对象。
5.匿名内部类中定义的方法最好不要超过三个，因为它本身就是为了简化。

//定义一个接口
interface Inter
{
	void method();
}

class Test
{
	//function方法返回一个接口类型的对象
	static Inter function()
	{
		//返回匿名内部类对象
		return new Inter()
		{
			public void method()
			{
				System.out.println("method");
			}
		}
	}

	public static void main(String[] args)
	{
		Test.function.method();
	}
}

包（package）
1.对类文件进行分类分类管理
2.给类提供多层命名空间
3.写在程序文件第一行
4.类名的全称是：包名.类名
5.包也是一种封装形式
总结：
1.包与包之间访问，被访问包中的类以及类中的成员。需要被public修饰
2.不同包中的子类还可以直接访问父类中被protected修饰的成员
3.包与包之间可以使用的权限只有两种，public，protected
         public  protected  default private
同一类中    ok       ok         ok     ok
同一包中    ok       ok         no     no
子类：      ok       ok         no     no
不同包中    ok       no         no     no
----------- android培训、 java培训、java学习型技术博客、期待与您交流！ ------------