阶段性思想总结

阶段总结：
面向对象：
	1，面向对象是一种符合现实生活中的思想。
	2，面对对象将复杂的事情简单化。
	3，面向对象将程序员从执行者变成了指挥者。
	这三点可以用于理解面对对象，也可以用于面试。

	相对于面向过程而言的，
	把大象放进冰箱里。
	面向过程：
	1，定义开的方法，定义存放的方法，定义关闭的方法。
	强调的是这些动作。
	面向对象：
	强调的是被操作的事物，
	先描述冰箱，描述大象。
	冰箱中定义了开，放，关的行为。
	只要指挥冰箱做事情，调用它的开方法，在调用放的方法，将大象作为参数存入，在调用关的方法。

	程序员就从执行者，变成了指挥者。

	又一示例：
	窗口操作：
	面向过程：强调的是移动，关闭等动作。
	移动窗口，关闭窗口。
	面向对象：强调是被操作的事物（窗口）
	窗口移动，窗口关闭。


----------------------------
用计算机语言其实就是在描述现实生活中的事物。
如果通过java语言来完成。

先对事物进行描述。其实就是java中的类。类其实通过现实中的事物分析了解其特性后，抽象而来的。

根据事物的描述产生实体，指挥实体做事情即可。其实就是通过类建立的对象，并通过对象调用其成员。

应该有的思想：
写java代码其实是先有思想，并用java代码将你的思想进行了体现。
对事物先进行分析，分析了其属性和行为后，通过class以及类中的成员变量和成员函数，将这些属性和行为进行计算机体现。



类和对象的关系:
类是事物的描述。
对象是该事物的实体。

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

class Student
{
	private String name;
	private int age;
	private String id;
	Student()
	{
		//super();  隐式      
	}
	Student(String name,int age,String id)
	{
		this.name = name;
		this.age = age;
		this.id = id;
	}

	public void setName(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
	
	public String toString()
	{
		return "Student info :"+name+","+age+","+id;
	}

}

	
class StudentDemo
{
	public static void main(String[] args)
	{
		Student s = new Student("lisi",30,"007");

		System.out.println(s.toString());//Student@234adf
		
	}
}

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

曾经学习的小思想的应用。
计数器：
class Count
{
	private int num;
	Count()
	{
		this(0);
	}
	Count(int num)
	{
		this.num = num;
	}

	public void setNum(int num)
	{
		this.num = num;
	}
	public int getNum()
	{
		return num;
	}

	public void add()
	{
		add(1);
	}

	public void add(int n)
	{
		num += n;
	}
}



class CountDemo
{
	public static void main(String[] args)
	{

		Count c = new Count();
		for(int x=1; x<=100; x++)
		{
			if(x%6==0)
				c.add();
		}
		System.out.println(c);

	/*
		int count =  0;
		for(int x=1; x<=100; x++)
		{
			if(x%6==0)
				count++;
		}
		System.out.println("count="+count);
	*/
	}
}


练习：
画矩形，获取矩形的面积，周长。

class Rec
{
	private double length;
	private double width;
	Rec(double length,double width)
	{
		this.length = length;
		this.width = width;
	}

	public void draw()
	{
		for(int x=0; x<width; x++)
		{
			for(int y=0; y<length; y++)
			{
				System.out.print("*");
			}
			System.out.println();
		}
	}
	public double getArea()
	{
		return length*width;
	}
	public double getZhouChang()
	{
		return (length+width)*2;
	}
	public String toString()
	{
		return "rec:"+length+","+width;
	}
}
class Circle
{
	private int radius;
	public static final double PI = 3.14;
	Circle(int radius)
	{
		this.radius = radius;
	}
	public double getArea()
	{
		return redius*radius*PI;
	}
	public double getZhouChang()
	{
		return r2*radius*PI;
	}
}

class RecDemo
{
	public static void main(String[] args)
	{
		Rec r = new Rec(6,4);
		r.draw();
	}
}

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

面向对象特征：
	1，封装
		隐藏实现细节，提高安全性。
	2，继承
		提高了代码的复用性，让类与类之间产生了关系，而来出现了多态。
	3，多态
		增强了程序的扩展性。



通过圆形和矩形的共性内容向上抽取图形类。
/*
abstract class Shape
{
	abstract double getArea();
	abstract double getZhouChang();
}
*/
interface Shape
{
	abstract double getArea();
	abstract double getZhouChang();
}

class Rec implements Shape
{
	//内容同上。
}



另一个例子：
描述学生很简单，有可能以后出现和学生类似的事物，
为了增强扩展性。思考学生是否具备其他事物的共性内容呢，比如，通常有学生就有讲师。

class AgeExceptione extends RuntimeException
{
	AgeExceptione(String mess)
	{
		super(mess);
	}
}

class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		if(age<=0)
			throw new AgeException("年龄出了问题");
		this.name = name;
		ths.age = age;
	}
	public void setName(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
	
}

class Student extends Person
{
	priavte String id;
	Student(String name,int age,String id)
	{
		super(name,age);
		this.id = id;
	}
	public void study()
	{
		
	}
}


N年后：

class Teacher extends Person
{
	private String number;
	Teacher(String name,int age,String number)
	{
		super(name,age);
		this.number = number;
	}
	public void teach()
	{
		
	}
}
	


java支持单继承。
java支持多层继承
1，子类可以获取最多的功能。
2，父类中定义的是继承体系的共性功能。
技巧：查阅API的时候，先看该继承体系的父类或者顶层接口。了解体系的基本功能应用。
	通过直接建立最子类对象即可使用该体系。



class Father
{
	String name;
	void da(Son s)
	{
		s.pao();
	}
	void da(Daughter d)
	{
		d.cry();
	}
}

class Son extends Father
{
	void pao()
	{
		System.out.println("son pao");
	}
}

class Daughter extends Father
{
	void cry()
	{
		System.out.println("dau pao");
	}
}

class Family
{
	public static void main(String[] args)
	{
		Father f = new Father();
		f.da(new Son());
	}
}



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

接口：
1，程序的功能扩展。
2，对外暴露的规则。
3，降低了程序的耦合性。
延续了多继承机制，但通过多实现接口的方式来体现。

一个类在继承另一个类的同时可以实现多个接口。

接口中的成员都是公有的。


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

设计模式：
1，单例设计模式
解决什么问题：保证类的对象唯一性 。
class Single
{
	private static final Single s = new Single();
	private Single(){}
	public static Single getSingle()
	{
		return s;
	}
}

2，模板方法设计模式
解决问题：提高功能的扩展性。
什么时候用模板方法设计模式：
	当定义功能时，功能中一部分可以确定，一部分不确定的时候。就使用模板方法设计模式。
	可抽象可不抽象，因为可以有默认的实现。
abstract class Template
{
	void template()
	{
		code...;

		method();
		code...;
	}
	abstract void methdo();
}

示例：
abstract class GetTimeTamplate
{
	public final  void getTime()
	{
		long start = System.currentTimeMillis();
		code();
		long end = System.currentTimeMillis();
		System.out.println(end-start);
	}
	abstract void code();
}



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

异常：
	对程序中出现的不正常情况进行描述。并封装成对象。
	封装成对象的好处：指挥该对象做事情。

	自定义异常：
	继承Exception或者RuntimeExcepion即可。

	还可以通过构造函数调用super将异常信息向上传递。

	class NoException extends Exception
	{
		NoException(){}
		NoException(String mess)
		{
			super(mess);
		}
	}

	异常处理方式：
	1，try
	2，throws

	什么时候使用这两种情况呢？
	当定义功能时，功能因为传递的参数，而引发问题，将该问题声明出来让调用者知道，这是就是抛throws。

	最终调用抛出异常的功能方法时，需要try。

	当覆盖了父类没有抛出异常的方法时，子类的方法出现问题，只能try，不能抛。

	特殊：
	try catch finally

	finally：通常都用于关闭资源。

	final  finalize fianlly有什么区别？