2016 January 24 Java

Java 基础

内部类

内部类可以直接调用外部类的私有属性缺点：打乱类的结构 如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。 静态内部类

代码块

构造块

public class DaiMaKuai01 {
	/**
	 * 构造块
	 */
	{
		System.out.println("通用构造块");
	}
	
	/**
	 * 构造方法一
	 */
	DaiMaKuai01(){
		System.out.println("构造方法一");
	}
	
	/**
	 * 构造方法二
	 * @param i
	 */
	DaiMaKuai01(int i){
		System.out.println("构造方法二");
	}
	
	public static void main(String[] args) {
		DaiMaKuai01 demo1 = new DaiMaKuai01();
		DaiMaKuai01 demo2 = new DaiMaKuai01(2);
	}
}

静态代码块

public class DaiMaKuai02 {
	/**
	 * 构造块
	 */
	{
		System.out.println("构造代码块");
	}
	/**
	 * 静态代码块
	 */
	static{
		System.out.println("静态代码块");
	}
	
	/**
	 * 构造方法一
	 */
	DaiMaKuai02(){
		System.out.println("构造方法一");
	}
	
	/**
	 * 构造方法二
	 */
	DaiMaKuai02(int i){
		System.out.println("构造方法二");
	}
	
	public static void main(String[] args) {
		DaiMaKuai02 demo01 = new DaiMaKuai02();
		DaiMaKuai02 demo02 = new DaiMaKuai02(2);
	}
}

调用构造方法的时候首先调用静态代码块且只调用一次，然后调用哦古着代码块，最后调用构造方法 ## 形参传递方法 ##

权限控制

private（私有） get,set 方法 package（包访问权限） protected（子类访问权限） public（公共访问权限）

	private	package（默认的）	protected	public
同一类中	√	√	√	√
同一包中			√	√
子类中			√	√
全局范围				√

String类

实例化方法实例化一：String name1 = “张三”; 实例化二：String name2 = new String(“李四”);
比较方法 “==”，比较应用（指向的地址）；”equals方法”比较具体的内容
两种实例化区别直接赋值实例化：创建的对象存放到字符串的地址池中，加入存在则不会再创建 new对象方式：每次都创建一个新的对象
字符串的类容具有不可改变性

Java继承

继承定义和基本使用关键字：extends 定义：子类能继承父类的属性和方法注意：Java只能单继承私有方法不能继承
方法的重写（override）
super关键字

Final关键字

final修饰类，则该类不能被继承 final修饰方法，则该方法不能被子类重写 final修饰的变量，则该变量不能被修改，即变为常量

抽象类

定义：含有抽象方法的类称为抽象类，不能生成对象（即不能被实例化）注意：

包含一个抽象方法的类是抽象类
抽象类和抽象方法都要用abstract关键字声明
抽象方法只要声明而不需要实现
抽象类的子类必须重写（override）抽象类中的全部抽象方法
抽象类不能被实例化

接口

定义：一种特殊的抽象类，由全局变量和公共的抽象方法所组成特性：

一个类可以实现一个或多个接口
先继承后实现
接口可以多继承
接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字
接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字
接口中的方法都是公有的

对象的多态性

Java中多态性的体现：

方法的重写（override）和重载（overlord）
可以用父类的引用指向子类的具体实现，而且可以随时转换为其他子类的具体实现对象的转型：向上转型：子类对象->父类对象向下转型：父类对象->子类对象 不安全

// 向下转型
Animal animal = new Dog();
animal.say();
// 更换其他子类的具体实现
animal = new Cat();
// 向上转型一
Dog dog = (Dog) animal;
dog.say();
// 向上转型二(不安全)
Cat cat = (Cat) animal;
cat.say();

Object类

object类是所有类的父类常用方法： public String toString（）返回该对象的字符串表示 public boolean equals（Object obj）指示其他某个对象是否与这个对象“相等”（比较引用）

匿名内部类

public interface A {
	public void A();
}

public class Test {
	public void test(A a){
		a.A();
	}
	
	public static void main(String[] args) {
		Test t = new Test();
		t.test(new A() {
			// 内部匿名类
			@Override
			public void A() {
				System.out.println("只使用一次");
			}
		});
	}
}

设计模式

单例模式 饿汉式：在类创建的同时就已经实例化一个静态的对象供系统使用,以后不再改变懒汉式：只在第一次调用的时候实例化

public class Signleton1 {
	/**
	 * 构造方法私有
	 */
	private Signleton1() {
	}
	
	/**
	 * 饿汉式单例实现
	 */
	private static final Signleton1 signle = new Signleton1();
	
	/**
	 * 静态工厂方式
	 */
	public static Signleton1 getInstance(){
		return signle;
	}
}

public class Signleton2 {
	/**
	 * 构造方法私有
	 */
	private Signleton2() {
	}
	/**
	 * 懒汉式单例实现,第一次调用的时候实例化
	 */
	private static Signleton2 signle;
	/**
	 * 静态工厂 synchronized 同步，防止多线程
	 */
	public synchronized static Signleton2 getInstance() {
		if (signle == null) {
			// 第一次调用的时候实例化
			System.out.println("只在第一次调用的时候实例化");
			signle = new Signleton2();
		}
		return signle;
	}
}

public class Test {
	public static void main(String[] args) {
		// 饿汉式单例实现
		Signleton1 signle1 = Signleton1.getInstance();
		Signleton1 signle2 = Signleton1.getInstance();
		// 只能实现一个对象
		System.out.println("饿汉式两次实现时候是否为同一对象" + signle1.equals(signle2));
		// 懒汉式单例实现
		Signleton2 signle3 = Signleton2.getInstance();
		Signleton2 signle4 = Signleton2.getInstance();
		// 只在第一次调用的时候实例化
		System.out.println("懒汉式两次实现时候是否为同一对象:" + signle3.equals(signle4));
	}
}

比较：饿汉式是线程安全的,在类创建的同时就已经创建好一个静态的对象供系统使用,以后不在改变懒汉式如果在创建实例对象时不加上synchronized则会导致对对象的访问不是线程安全的推荐使用第一种。