黑马程序员_面向对象

------- android培训、java培训、期待与您交流！ ---------- 

面向对象一共用三个特征:

封装(encapsulation)继承(inheritance)多态(polymorphism)

 

封装:

 封装是面向对象编程的核心思想,将对象的属性和行为封装起来,而将对象的属性和行为封装起来的
载体就是累,类通过对客户隐藏其实现细节,这就是封装的思想,例如:用户使用计算机,只要使用手指
敲击减排就可以实现一些功能,用户无需知道计算机内部是如何工作的,即使用户可以是碰巧知道计算机工作原理,
单在使用计算机时并不完全依赖于计算机工作原理这些细节.
 采用封装的思想保证了类内部数据结构的完成性,应用该类的用户不能轻易直接操纵次数据结构.而
只能捷星类润徐公开的数据,这样必灭了外部对内部数据的影响,提高了程序的可维护性.

 
 以后开发:其实就是找对象使用,没有对象,就创建一个对象.
 找对象,建立对象,使用对象,维护对象的关系.以后写写程序的时候.要养成一个习惯.想要实现一个功能的时候
要找一个对象.如果没有对象.那么就创建一个对象.并把所用的功能定义到对象当中.这样大家都能用,这样提高了
功能的复用性,对象其实就是对功能的封装.

 

类和对象的关系:
 类就是:对现实生活中事物的描述.
 对象:就是这类事物,实实在在存在的个体.

 
 现实中的对象:张三,李四
 想要描述:提取对象的共性内容.对具体的抽象.
 描述时.这也对象的共性有姓名年龄,性别,学习java的功能.

 映射到java中.描述就是class定义的类.
 具体对象就是对应java在堆内存中使用new建立的实体

.

创建对象并使用对象例子:

class Car//对Car这类事物进行描述
{
	String color = "red";
	int num = 4;
	void show()
	{
	System.out.println("color="+color+"..num="+num);
	}
}
class CarDemo
{
	public static void main(String[] args)
	{
	Car c = new Car();//建立对象
	c.color = "black";//对对象的属性进行修改
	c.show();//使用对象的功能。
	}
}

 

匿名对象
 匿名对象是对象的简化形式
 匿名对象两种使用情况
 当对对象方法仅进行一次调用的时
 匿名对象可以作为实际参数进行传递
 如
  new Car().run();

 

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

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

封装原则：
 将不需要对外提供的内容都隐藏起来。
 把属性都隐藏，提供公共方法对其访问。

 private:私有,权限修饰符.用于修饰类中的成员.(成员变量,成员函数).私有只在本类中有效.
 注意:私有仅仅是封装的一种表现形式.封装之后要对外提供访问方式.
 之所以对外提供访问方式.就因为可以在访问方式中假如逻辑判断等语句.对访问的数据惊醒操作.提高代码的健壮性.

 this:用于区分局部变量和成员同名的情况
 this:代表其所在函数所属对象的引用。换言之：this代本类对象的引用。简单说,哪个对象在调用this所在的函数就代表哪个对象.
 this的应用当定义类中功能时,该函数内部要用到调用该对象时,这时this来表示这个对象.单反本来功能内部使用了本类对象,都用this表示
 静态：static。

用法：是一个修饰符，用于修饰成员(成员变量，成员函数).
当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，
还可以直接被类名调用。类名.静态成员。

 

示例:

class Person//面向对象
{
	private int age;//将age私有化.私有只在本类中有效
	public void setAge(int age)//私有之后可以在函数中进行判断等操作
	{
		if(age>0 && age<130)
		{
			this.age=age;//this代表本类对象.谁调用就是谁
			speak();
		}
		else
			System.out.println("错误");
	}
	public int getAge()
	{
		return age;
	}
	void speak()
	{
		System.out.println("age="+age);
	}
}

class  PersonDemo
{
	public static void main(String[] args) 
	{
		Person p=new Person();
		p.setAge(40);
		//p.speak();
	}
}

 

static 特点：
 1，随着类的加载而加载。
    也就说：静态会随着类的消失而消失。说明它的生命周期最长。

 2，优先于的对象存在
 明确一点：静态是先存在。对象是后存在的。

 3，被所有对象所共享

 4，可以直接被类名所调用。

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

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

 静态使用注意事项：
 1，静态方法只能访问静态成员。
  非静态方法既可以访问静态也可以访问非静态。

 2，静态方法中不可以定义this，super关键字。
  因为静态优先于对象存在。所以静态方法中不可以出现this。

 3，主函数是静态的。
 静态有利有弊
 利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。
  可以直接被类名调用。
 弊端：生命周期过长。
    访问出现局限性。(静态虽好，只能访问静态。)

 
 静态的应用:
 每一个应用程序中都有共性的功能，
 可以将这些功能进行抽取，独立封装。
 以便复用。
 虽然可以通过建立ArrayTool的对象使用这些工具方法.对数组惊醒操作.
 发现了问题
  1.对象是用于封装数据的,可是ArrayTool对象中中未封装特有数据.

  2.操作数组的每一个方法都没有用到Arraytool对象中的特有数据.
 这时候结考据,让程序更加严谨,是不需要对象的,
 可以将ArrayTool中的方法都定义成static的,直接通过类名进行调用.
 将方法都静态后,可是方便与使用,单是该类还是可以被其他程序建立对象的.
 为了更加眼睛,强制让该类不能建立对象,
 可以通过狗仔函数私有化来完成.

示例: 

class ArrayTool
{
	private ArrayTool(){};
	//获取最大值
	public static int getMatArr(int[] arr)
	{
		int max=arr[0];
		for(int x=1;x<arr.length;x++)
		{
			if(arr[x]>max)
				max=arr[x];
		}
		return max;
	}
	//获取最小值
	public static int getMinArr(int[] arr)
	{
		int min=arr[0];
		for(int x=1;x<arr.length;x++)
		{
			if(arr[x]<min)
				min=arr[x];
		}
		return min;
	}
	//选择排序
	public static void arrSort(int[] arr)
	{
		for(int x=0;x<arr.length-1;x++)
		{
			for(int y=x+1;y<arr.length;y++)
			{
				if(arr[x]>arr[y])
				{
					swep(arr,x,y);
				}
			}
		}
	}
	//冒泡排序
	public static void bubbleSrot(int[] arr)
	{
		for(int x=0;x<arr.length-1;x++)
		{
			for(int y=0;y<arr.length-x-1;y++)
			{
				if(arr[y]>arr[y+1])
					swep(arr,y,y+1);
			}
		}
	}
	//用第三方变量来互换位置
	private static void swep(int[] arr,int a, int b)
	{
		int temp=arr[a];
		arr[a]=arr[b];
		arr[b]=temp;
	}
	//打印数组
	public static void printArr(int[] arr)
	{
		for(int x=0;x<arr.length;x++)
		{
			if(x!=arr.length-1)
				System.out.print(arr[x]+",");
			else
				System.out.println(arr[x]);
		}
	}
	
}
class ArrayToolTest
{
	public static void main(String[] args)
	{
		int[] arr={1,5,79,36,4,6};
		//int min=ArrayTool.getMinArr(arr);
		//System.out.println(min);
		ArrayTool.arrSort(arr);
		ArrayTool.printArr(arr);
	}
}

静态代码块
 格式:
 static
 {
  静态代码块中执行的语句.
 }
 特点:随着类的加载而执行,只执行一次.并优先于主函数
 用于给类进行初始化的.\

示例:

class StaticCode
{
	static
	{
		System.out.println("a");
	}
}

单例设计模式:

解决一个类在内存只存在一个对象.

想要保证对象唯一.
 1.为了比秒其他程序过多建立该对象,先禁止其他程序建立该对象.
 2.还为了让其他程序可以访问到该类的对象,只好在本类中,自定义一个对象.
 3.为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式.

这三步怎么用代码实现呢?
 1.将构造函数私有化.
 2.在类中创建一个本类对象.
 3.提供一个方法可以获取到该对象.

示例:

	饿汉式
class Student
{
	private int age;
	//设置age
	public void setAge(int age)
	{
		this.age=age;
	}
	//获取age
	public int getAge()
	{
		return age;
	}
	//饿汉式
	//禁止其他程序建立对象,所以私有化
	private Student(){};
	//在类中创建一个本类对象
	private static Student s=new Student();
	//提供方法进行访问
	public static Student getInstance()
	{
		return s;
	}
}

class  SingleDemo
{
	public static void main(String[] args) 
	{
		//因为不可以创建对象.所以调用静态方法
		Student ss=Student.getInstance();
		Student s1=Student.getInstance();
		ss.setAge(20);
		System.out.println(s1.getAge());
	}
}

 懒汉式:

对象是方法被调用时,才初始化,也叫做对象的延时加载,成为懒汉式.
Single类进内存,对象还没有存在,值调用了getInstance方法时,才建立对象

示例:

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

 

                                                                        继承(inheritance)
 多个类中存在相同属性和行为时，将这些内容抽取到 单独一个类中，那么多个类无需再定义这些属性和行 为，只要继承单独的那个类即可。
 多个类可以称为子类，单独这个类称为父类或者超类。子类可以直接访问父类中的非私有的属性和行为。

 通过extends 关键字让类与类之间产生继承关系。
 class SubDemo extends Demo{}
 继承的出现提高了代码的复用性。
 继承的出现让类与类之间产生了关系，提供了多态的前提。

继承的特点:
 Java只支持单继承，不支持多继承。
 一个类只能有一个父类，不可以有多个父类。
 class SubDemo extends Demo{}
 class SubDemo extends Demo1,Demo2...
 Java支持多层继承(继承体系)
 class A{}
 class B extends A{}
 class C extends B{}

定义继承需要注意：
 不要仅为了获取其他类中某个功能而去继承
 类与类之间要有所属( " is a " )关系，xx1是xx2的一种。
 super关键字:
 super和this的用法相同
 this代表本类应用
 super代表父类引用
 当子父类出现同名成员时，可以用super进行区分
 子类要调用父类构造函数时，可以使用super语句。
 子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重 写或者复写。
 父类中的私有方法不可以被覆盖。
 在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

覆盖注意事项：
 覆盖时，子类方法权限一定要大于等于父类方法权限
 静态只能覆盖静态。

 覆盖的应用：
 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

子类的实例化过程:
 子类中所有的构造函数默认都会访问父类中空参数的 构造函数
 因为每一个构造函数的第一行都有一条默认的语句 super();
 子类会具备父类中的数据，所以要先明确父类是如何 对这些数据初始化的。
 当父类中没有空参数的构造函数时，子类的构造函数 必须通过this或者super语句指定要访问的构造函数。

抽象:
 抽象类的特点:
 1.抽象方法一定在抽象类中.
 2.抽象方法和抽象类都必须被absstrch关键字修饰.
 3.抽象类不可以用new创建对象.因为调用抽象方法没有意义.
 4.抽象类中的方法要背使用.必须由了子类复写起所以的抽象方法后.建立子类对象调用.
  如果子类只覆盖了部分抽象方法.那么该子类还是一个抽象类.

示例:

abstract class Employee//建立员工抽象类
{
	//将三个属性设为私有
	private String name;
	private String id;
	private double pay;
	//用构造函数给三个属性初始化
	Employee(String name,String id,double pay)
	{
		this.name=name;
		this.id=id;
		this.pay=pay;
	}
	//因为经理和员工工作的不一样所以为抽象
	public abstract void work();
}
//经理类继承了员工
class Manager extends Employee
{
	private int bouns;
	//继承了员工的属性并添加了bouns奖金
	Manager(String name,String id,double pry,int bouns)
	{
		super(name,id,pry);//父类已经定义完了.直接使用就OK了
		this.bouns=bouns;
	}
	public void work()//覆盖抽象方法.
	{
		System.out.println("manager work");
	}
}
class Pro extends Employee//继承员工
{
	Pro(String name,String id,double pry)
	{
		super(name,id,pry);
	}
	public void work()//覆盖员工的抽象方法
	{
		System.out.println("pro work");
	}
}
class AbstractTest 
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}

 

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

    多态
 可以理解为事物存在的多种体现形态。

 人：男人，女人
 动物：猫，狗。
 猫 x = new 猫();
 动物 x = new 猫();

1，多态的体现
 父类的引用指向了自己的子类对象。
 父类的引用也可以接收自己的子类对象。

2，多态的前提
 必须是类与类之间有关系。要么继承，要么实现。
 通常还有一个前提：存在覆盖。

3，多态的好处
 多态的出现大大的提高程序的扩展性。

4，多态的弊端：
 虽然提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5，多态的应用

6，多态的出现代码中的特点(多态使用的注意事项)

在多态中成员函数的特点:
 在编译时期:残月引用型变量所属的类候总是否有调用的方法.如果有,则编译通过.如果没有.则编译失败
  在运行时期:残月对象所属的类中是否有调用的方法.
 简单的总结就是:成员函数在多态调用时,编译看左边.运行看右边.

 

 在多态中.成员变量的特点:
  无论编译和运行,都残月左边(引用型变量所属的类);

 

 在多态中.静态成员函数的特点:
  无论便是和运行.都参考左边
 instanceof 是用于判断对象的类型

示例:

class Mainboard//定义一个主板类
{
	void run()//让主板运行
	{
		System.out.println("mainboard  run");
	}
	public void usePCI(PCI p)//PCI p=new NetCard()//接口型引用指向自己的子类对象
	{
		if(p!=null)//如果p不等于空开始执行开启.关闭
		{
			p.open();
			p.close();
		}
	}
}
interface PCI//PCI接口
{
	public void open();
	public void close();
}
class NetCard implements PCI//定义网卡.实现PCI接口
{
	public void open()//覆盖其开启和关闭的方法
	{
		System.out.println("netcard open");
	}
	public void close()
	{
		System.out.println("netcard colse");
	}
}
class  DuoTaiDemo4
{
	public static void main(String[] args) 
	{
		Mainboard m=new Mainboard();//创建主板对象
		m.run();
		m.usePCI(new NetCard());//使用主板的PCI.往里面插入网卡.
	}
}

Object:

是所有对象的直接后者间接父类.传说中的上帝.
该类中定义的肯定是所有对象都具备的功能.

Object类中已经提供了对对象是否相同的比较方法.

如果自定义类中也有比较相同固定功能.没有必要重新定义.
只要纤细父类中的功能.建立自己特有的比较内容即可.

示例:

class Demo
{
	//将num成员变量私有化
	private int num;
	//用构造函数将num初始化
	Demo(int num)
	{
		this.num=num;
	}
	//覆盖Object类中的equals方法将两个类中的num进行比较
	public boolean equals(Object obj)
	{
		//用instanceof方法来判断两个类是否相.不同的话直接false
		if(!(obj instanceof Demo))
			return false;
		//因为传进来的是Object,Object类中没有num方法.使用多态向下转型Demo.
		Demo d=(Demo)obj;
		return this.num==d.num;//返回本类num和传进来的num是否相同

	}
	//覆盖Object类中的方法.
	public String toString()
	{
		return "Demo"+num;
	}
}

class ObjectDemo 
{
	public static void main(String[] args) 
	{
		//创建Demo对象并传给num 4
		Demo d=new Demo(4);
		Demo d2=new Demo(1);
		//往d对象里穿进去d2用定义好的equals进行比较
		System.out.println(d.equals(d2));
		//打印类名加num.
		System.out.println(d.toString());
	}
}

------- android培训、java培训、期待与您交流！ ----------