Java面向对象与设计模式-优快云博客

本文介绍了Java中的类与对象概念、单例模式、抽象类、接口、模板方法模式等面向对象特性，以及如何使用这些特性来设计更灵活、可扩展的软件系统。

类与对象
理型论（theory of Forms，或theory of Ideas）
柏拉图认为，人类感官可见的事物，并不是真实，只是一种表相，它是完美理型的一种投射。
class 抽象理型 object 具体事物

创建：

class  apple extends fruit
{
	apple()
	{
		super();  //调用fruit构造函数
	}
}

构造函数

1.创建自己 2.调用父类构造函数

代码块、静态代码块

class fu   //1.父类优先子类加载
{
        static    //2. static与class同时加载。 第一个输出
        {
                System.out.println("父类的静态代码块");   
        }

         {        //5.父类被实例化。非静态代码块优先于构造函数。第二个输出                          
        System.out.println("父类非静态代码块"); //8.父类子类静态代码块加载完后，执行父类非静态代码块。第五个输出
     }

      fu()     //6.父类被实例化。非静态代码块优先于构造函数。第三个输出 
          {
                System.out.println("父类的构造器");  //9.父类非静态代码块加载完后，执行构造函数。第六个输出
        }
}

class zi  extends fu  //3.子类后加载
{
        static fu f= new fu();  //4. static与claa同时加载。父类被实例化。
        static   //7.static与claa同时加载。第四个输出
        {
                System.out.println("子类的静态代码块");
        }
        
        {           //10.父类构造函数加载完后，执行子类非静态代码块。第七个输出        
        System.out.println("子类非静态代码块");  
     }
           zi()   //11.子类静态代码块加载完后，执行子类构造函数。第八个输出  
          {
                System.out.println("子类的构造器");
        }

}

class demo
{
        public static void main(String[] agrs)
        {
                zi z =new zi();
        }
}

问题：定义一个学生类, 需要有姓名, 年龄, 考试成绩三个成员属性. 属性(成员变量)需要私有并提供get, set方法, 可以通过构造函数进行初始化。　

class  Student
{
	private String name;
	private int age;
	private int score;

	Student()
	{
	
	}

	Student(String name,int age,int score)
	{
		this.name = name;
		this.age = age;
		this.score = score;
	}

	void setName(String name)
	{
		this.name=name;
	}

	String getName()
	{
		return this.name;
	}

	void setAge(int age)
	{
		this.age=age;
	}
	
	int getAge()
	{
		return this.age;
	}

	void setScore(int score)
	{
		this.score=score;
	}

	int getScore()
	{
		return this.score;
	}
}

单例模式饿汉式（推荐）

	private String name;

	void setName(int name)
	{
		this.name=name;
	}

	int getName()
	{
		return name;
	}

	private Demo()  //禁止外部实例化
	{
	}
	
	private static Demo d = new Demo(); //内部实例化

	public static Demo getobject() //对象调用接口
	{
		return d;
	}

abstract抽象类的特征　

                                //特征1：抽象类无法实例化。
abstract class demo             //特征2：类中存在抽象方法，必须声明为抽象类。
{
        abstract void method(); //特征3：没有方法体，必须声明为抽象方法。
}

abstract class demo 
{
        abstract void method();
        void method()           //特征4：可以有非抽象方法
        {
                        System.out.println("我是正常方法");
        }
}

interface接口的特征：

                                                  //特征1 无法直接实例化
interface a  
{
                public static final int num=1;    //特征2   public static final 可以缺省，编译器自动补全。
                public abstract void method();    //特征3  public abstract 可以缺省，编译器自动补全。建议不要缺省。不能是static，不然无法override
}

class demo implements  a,b                       //特征4  实现类的多继承，以解决Java只能单继承，不支持多继承的问题。
{                                                //特征5 只能存在抽象方法
}

interface a extends b //注意：接口继承接口用extends

模板方法模式

abstract class Demo
{
	public final void getmethod()   //1.确定的，不可修改的
	{
		  //禁止重写
	}
	public abstract void method();//2.抽象的，可修改的。
}

object instanceof class object 是class 的一个实例

object.equals(obj2) 返回boolean类型

class zidingyi extends Exception
{
	zidingyi(String str)
	{
		super(str);
	}
}

class Conut
{
	void math()throws  zidingyi
	{
		int i=11;
		if(i>10)
		{
			throw new zidingyi("异常 你好");
		}
		else
		{
			System.out.println("无异常");
		}
	}
}

class  demo
{
	public static void main(String[] args)
	{
		try
		{
			Conut c = new Conut();
			c.math();
		}
		catch (Exception e)
		{
			System.out.println(e.toString());
		}
		finally
		{
			System.out.println("关闭SQL资源");
		}
	}
}

package //url;

import //建议不要写通配符

/*内部类
内部类可以直接访问外部类的成员，包括私有成员。
而外部类要访问内部类中的成员必须要建立内部类的对象。
*/

class wai
{
	private String str = "外部属性";
	class nei
	{
		private String neistr = "内部属性";
		void neifangfa()
		{
			System.out.println(str);//直接访问外部类成员
		}
	}

	void waifangfa()
	{
		nei n = new nei(); //建立内部类的对象。
		System.out.println(n.neistr);
	}
}


class  demo
{
	public static void main(String[] args) 
	{
			wai w = new wai();
			w.waifangfa();

			wai.nei n = new wai().new nei(); //先实例化外部，再内部。
			n.neifangfa();
	}
}

当内部类中定义了静态成员，该内部类必须是static的。
当外部类中的静态方法访问内部类时，内部类必须是static的。

转载于:https://www.cnblogs.com/weimingtfm/archive/2012/04/01/2418957.html