java笔记-----代码块、单例设计模式、继承

foreach与可变参数

for(类型 变量名称：数组或集合)

{

//输出操作

}

/**
	foreach与for的区别
	foreach:
for(类型 变量名称：数组或集合)
{
	//输出操作
}
*/
class Demo 
{
	public static void main(String[] args) 
	{
		String[] names = {"小白","小红","小利"};
		for (int i=0; i<names.length; i++)
		{
			System.out.print(names[i]+"	");
		}
		System.out.println("\n----------------------------");
		//foreach
		for(String name:names)
		{
			System.out.print(name+"	");
		}
	}
}

可变参数

/**
	可变参数  JDK1.5新特性
	1、一个方法中，只能出现一个可变参数
	2、多个参数时，可变参数必须是最后一个
*/
class Demo
{
	public static void main(String[] args) 
	{
		String[] names = {"小白","小红","小利"};
		//调用方法
		//method(names);
		method1("小白","小莫");
	}
	public static void method2(int num,String... names)//多个参数，可变参数写在后面
	{
		
	}
	public static void method(String[] names)
	{
		for(String name:names)
		{
			System.out.print(name+"	");
		}
	}
	//参数为可变参数
	public static void method1(String... names)
	{
		for(String name:names)
		{
			System.out.print(name+"	");
		}
	}
}

代码块

1、普通代码块

2、构造快

3、静态块

/**
   代码块
   1、普通代码块：在方法中的代码，作用域只在最近的{}内
   2、构造块：在构造对象时调用，再类中的代码块，先于构造方法执行
   3、静态块：在类加载时，只执行一次
*/
class Demo
{
	//构造块
	{
		System.out.println("我是构造块");
	}
	public static void main(String[] args)
	{
		Demo d = new Demo();
		Demo d1 = new Demo();
	}
	//静态块
	static
	{
		System.out.println("我是静态块");
	}
	//普通代码块
	{
		String info = "我在学习代码块";
		System.out.println(info);
	}
}

单例设计模式

单例设计模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点

1、构造方法私有化

2、声明一个本类对象

3、给外部提供一个静态方法获取对象实例

两种实现方式：

饿汉式：

懒汉式：

/**
	单例设计模式(singleton)
*/
class SingletonDemo
{
	public static void main(String[] args)
	{
		Singleton1 s = Singleton1.getInstance();
		s.print();
		Singleton2 s1 = Singleton2.getInstance();
		s1.print();
	}
}
/**
	把该类设计成单例设计模式
	饿汉式
*/
class Singleton1
{
	//定义一个本类对象并实例化
	private static Singleton1 s = new Singleton1();
	//构造方法私有化
	private Singleton1(){}
	public static Singleton1 getInstance()
	{
		return s;
	}
	public void print()
	{
		System.out.println("饿汉式-设计模式");
	}
}
/**
	把该类设计成单例设计模式
	懒汉式(多线程访问式会有安全问题)
*/
class Singleton2
{
	//定义一个本类对象并实例化
	private static Singleton2 s = null;
	//构造方法私有化
	private Singleton2(){}
	public static Singleton2 getInstance()
	{
		if(s==null)
		{
			s = new Singleton2();
		}
		return s;
	}
	public void print()
	{
		System.out.println("懒汉式-设计模式");
	}
}

继承

继承的语法：

继承的限制

1、java中只能实现单继承，也就是一个类只能有一个父类

2、允许多层继承，即：一个子类可以有一个父类，一个父类还可以有其它的父类。

3、继承只能继承非私有的属性和方法

4、构造方法不能被继承

/**
	继承的基本概念
	非私有的：public default protected
	访问修饰符：public（公有）private（私有）default（默认）protected（保护型）
	注意：构造方法不能被继承
*/
class ExtendsDemo 
{
	public static void main(String[] args) 
	{
		Zi z = new Zi();
		z.say();
	}
}
class Fu
{
	protected String name;
	private static int age = 10;
	//构造方法
	public Fu()
	{
		System.out.println("我是构造方法");
	}
	public static void say()
	{
		System.out.println("你好，我是父类");
		System.out.println(age);
	}
}
class Zi extends Fu
{
	public Zi()
	{
		System.out.println("我是子类构造");
	}
}
class Zi1 extends Fu
{

}