java基础<基础知识整理>

对象的初始化过程

一、对象进行new以后的内存发生了那些事情

对象调用成员过程

一、对象条用成员过程

单例设计模式

一、代码

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

1.禁止其他程序建立该类对象。

2.要在本类中自定义一个对象。

3.对外提供一些访问方式

饿汉式（一般用这个，因为比较安全）

class Single
{
	private Single(){}

	private static Single p=new Single();
	
	public static Single getInstance()
	{
			return p;
	}

}

懒汉式（线程不安全，可以加入synchronized关键字，但是效率过低）

class Single
{
	private Single(){}

	private static Single p=null;
	
	public static /*synchronized */Single getInstance()
	{
			if(p==null)
				p=new Single();
			return p;
	}

}

继承（概述）

一、概述

继承：
1.提高了代码的复用性。
2.让类与类之间产生了关系，有了这个关系，才有了多态的特性
3.java语言中只支持单继承(因为多继承容易带来安全隐患。当多个类中定义了
相同功能，当功能内容不同时，子类对象不确定要运行哪一个.)
但是java保留了多继承的机制，并用另一种体现形式来完成，即多实现。
4.查阅父类功能，创建子类对象使用功能。

注意：千万不要为了获取其他类的功能，简化代码而继承。
必须是类与类之间有所属关系才可以继承。

二、代码

将学生和工人的共性描述提取出来，单独进行描述，
只要让学生和工人与单独描述的这个类有关系就可以了。

class Person 
{
	String name;
	int age

}

class Student extends Person
{
	//String name;
	//int age=;
	void study()
	{
		System.out.println("good study");	
	}
}

class Worker extends Person
{
	//String name;
	//int age=;
	void study()
	{
		System.out.println("good work");	
	}
}

子父类中的变量、方法和构造方法的关系

一、变量的特点

如果子类中出现非私有的同名成员变量时，
子类要访问本类中的变量，用this
子类要访问父类中的同名变量，用super
super的使用和this的使用几乎一致。

二、方法的特点

当子类出现和父类一模一样的函数时，
当子类对象调用该函数，会运行子类函数的内容。
如同父类的函数被覆盖一样。(父类的函数依然存在于内存中，只不过没有运行）
这种情况是函数的另一个特性：重写（覆盖）

覆盖：
1.子类覆盖父类，必须保证子类权限大于等于父类权限。
2. 静态只能覆盖静态。

注意：重写与重载不同。 

三、构造方法的特点

1.在对子类对象进行初始化时，父类的构造函数也会运行，
那是因为子类的构造函数默认第一行有一条隐式的语句super()
super():会访问父类中空参数的构造函数。而且子类中所有的构造函数第一行都是super()

2.为什么子类一定要访问父类中的构造函数？
因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。
所以子类在对象初始化时，要先访问以下父类中的构造函数。
如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。

注意：super语句一定定义在子类构造函数的第一行。子类的构造函数的第一行也可以用子类的构造函数来代替
父类的构造函数，但是这并不影响对父类变量进行赋值，因为子类的构造函数中总会有一个调用父类的构造函数

四、需要能够理解的代码

class Person
{
	private String name;
	Person(String name)
	{
		this.name=name;
	}
	void show(){}
}

class Student extends Person
{
	Student(String name)
	{
		//super.name=name;
		super(name);
	}
	void method()
	{
		super.show();
	}
}

用以帮助理解以上代码的例子

class Person
{
	String name="zhangsan";
	Person(){};
	Person(String name)
	{
		this.name=name;
	}
	public String getName()
	{
		return this.name;
	}
}

class Student extends Person
{
	String name;
	Student(String name)
	{
		super(name);
	}
	/*public String getName()
	{
		return name;
	}
	*/

}

class  ExtendsDemo5
{
	public static void main(String[] args) 
	{
		Student s=new Student("wqz");
		String name=s.getName();
		String name2=s.name;
		System.out.println(name);//返回wqz
		System.out.println(name2);//返回null
	}
}

final关键字

一、概述

1.可以修饰类

被final修饰的类，不可以被继承。（为了避免被继承，被子类复写功能。）

2.可以修饰方法

被final修饰的方法，不可以被重写

3.可以修饰变量

被final修饰的变量是一个常量，只能赋值一次。既可以修饰成员变量，又可以修饰局部变量。只要这个

模板方法模式

一、代码

什么是模板方法？

答：在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去，由该类的子类去完成。

abstract class GetTime
{
	public final void getTime()
	{
		long start =System.currentTimeMillis();
		runCode();
		long end =System.currentTimeMillis();
		System.out.println("毫秒："+(end-start));
	}


	public abstract void runCode();

}

class SubTime extends GetTime
{
	public void runcode()
	{		
		for(int x=0;x<100;x++)
		{
			System.out.print("x");
		}	
	}
}


class  TemplateDemo
{
	public static void main(String[] args) 
	{
		SubTime st=new SubTime();
		st.getTime();
	}
}

接口

一、格式

1. interface 接口名字

{

public static final int NUM=3;

public abstract void show();

}

2. 接口中常见定义：常量，抽象方法。

接口里面的常量和抽象方法都有固定的修饰符

常量：public static final 

方法：public abstract

3. class Test    (extends Demo)   implements 接口名字1，接口名字2

{

}

4.接口与接口之间是继承关系

interface A

{}

interface B extends A

{}

interface Inter
{
	public static final NUM=3;
	public abstract void show();
}

class Test implements Inter
{
	public void show(){}
}

class InterfaceDemo 
{
	public static void main(String[] args) 
	{
		Test t=new Test();
		System.out.println(t.NUM);
		System.out.println(Test.NUM);
		System.out.println(Inter.NUM);
	}
}

二、接口的特点

1.接口是对外暴露的规则。

2.接口是程序的功能扩展。

3.接口可以用来多实现

4.类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。

5.接口与接口之间可以有继承关系

三、接口举例体现

abstract class Student
{
	abstract void study();

	void sleep()
	{
		System.out.println("sleep");
	}
}

interface Smoking
{
	void smoke();
}

class ZhangSan extends Student implements Smoking
{
	void study(){};
	public void smoke(){};
}

class Lisi extends Student
{
	void study(){};
}


class InterfaceDemo 
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}

Object类

一、概述

Object:是所有对象的直接后者的间接父类，传说中的上帝。
该类中定义的成员，是所有对象都具备的。

二、代码(equals()方法)

class Person
{
}

class Demo
{
}


class Demo1
{
	private int num;
	Demo1(int num)
	{
		this.num=num;
	}
	public boolean equals(Object obj)
	{
		if(obj instanceof Demo1)
		{
		Demo1 d=(Demo1)obj;
		return this.num==d.num;
		}
		else
			return false;
	}
}

class ObjectDemo
{
	public static void main(String[] args) 
	{
		Demo d1=new Demo();
		Demo d2=new Demo();
		Demo d3=d1;
		Demo1 d4=new Demo1(4);
		Demo1 d5=new Demo1(4);
		Demo1 d6=new Demo1(5);

		Person p=new Person();

		System.out.println(d1.equals(d2));//false
		System.out.println(d1.equals(d3));//true
		System.out.println(d1==d2);//false
		System.out.println(d1==d3);//true	
		System.out.println(d4.equals(d5));//返回true
		System.out.println(d4.equals(d6));//返回false
		System.out.println(d4.equals(p));//返回false


		//其实,equals()方法比较的就是————地址。
	}
}

三、代码（toSting()方法）

public String toString()
{
	return getClass().getName() + '@' + Integer.toHexString(hashCode());
}

包与包之间访问

一、会出现的问题

①PackageDemo.java:6: 错误: 找不到符号
                DemoA a=new DemoA();
                ^
  符号:   类 DemoA
  位置: 类 PackageDemo
PackageDemo.java:6: 错误: 找不到符号
                DemoA a=new DemoA();
                            ^
  符号:   类 DemoA
  位置: 类 PackageDemo


错误原因：类名写错。因为类名的全名是：报名.类名

②PackageDemo.java:6: 错误: 程序包packa不存在
                packa.DemoA a=new packa.DemoA();
                     ^
PackageDemo.java:6: 错误: 程序包packa不存在
                packa.DemoA a=new packa.DemoA();
 
错误原因：packa包不在当前目录下，需要设置classpath,告诉jvm去哪里找指定的packa包


③PackageDemo.java:6: 错误: DemoA在packa中不是公共的; 无法从外部程序包中对其进行访
问
                packa.DemoA a=new packa.DemoA();
                     ^
PackageDemo.java:6: 错误: DemoA在packa中不是公共的; 无法从外部程序包中对其进行访
问
                packa.DemoA a=new packa.DemoA();
                                       

错误原因：有了包范围变大，一个包中的类要被访问，必须要有足够大的权限，所以被访问的类要被public修饰



④PackageDemo.java:6: 错误: DemoA在packa中不是公共的; 无法从外部程序包中对其进行访
问
                packa.DemoA a=new packa.DemoA();
                     ^
PackageDemo.java:6: 错误: DemoA在packa中不是公共的; 无法从外部程序包中对其进行访
问
                packa.DemoA a=new packa.DemoA();


错误原因：类共有后，被访问的成员也要公有，才可以被访问。



总结：
①包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰

②不同包中的子类，还可以直接访问父类中被protected修饰的成员

二、访问权限

包与包之间可以使用的权限只有两种，public和protected

public      protected       defalut      private 
同一个类中 ok ok ok ok
同一个包中 ok ok ok
子类 ok ok
不同包中 ok

三、其他注意事项

一个java文件中，不可以出现两个以上的公有类、或者接口，因为一个类被public修饰后，该java文件的名字必须与该类的名字一致，如果出现两个以上的public类，无法明确该文件的名字与哪个类的名字一致。

基本数据类型——对象包装类

一、概述

基本数据类型对象包装类

byte	Byte
*int	Integer
short	Short
long	Long
boolean Boolean
float	Float
double	Double
*char	Character

基本数据类型对象包装类，
1.最常见的作用————用于基本数据类型和字符串类型之间做转换

1.1基本数据类型转成字符串
	基本数据类型+""
	基本数据类型包装类.toString(基本数据类型值)
	如：Integer.toString(34);将34整数编程"34"

1.2字符串转成基本数据类型
	xxx a=Xxx.parseXxx(String)
	如：int a=Integer.parseInt("123");
	如果int a=Integer.parseInt("a123");会报数字格式异常。

	Integer i=new Integer("123");
	int num=i.intValue();

2.十进制与其他进制进行转换

2.1 十进制转成其他进制
	二进制：toBinaryString();
	十六进制：toHexString();
	八进制:toOctalString();

2.2 其他进制转成十进制
	parseInt(String,radix);
	例：Integer.parseIn("110",10)

基本数据类型——对象包装类新特性

class  
{
	public static void main(String[] args) 
	{
		Integer x=4;//JDK1.5以后新特性————自动装箱。即自动完成了new Integer(4);
		x=x+2;//自动拆箱，变成了int类型，所以能和2进行数学运算。再将所得和，进行装箱赋给x.自动拆箱，实际上是进行了x.intValue()操作。

		

	}

	public static void method()
	{
		Integer x=new Integer("123");
		Integer y=new Integer(123);

		System.out.println(x==y);//false
		System.out.println(x.equals(y));//true
	}


	public static void method1()
	{
		Integer m=128;
		Integer n=128;
		System.out.println(m==n);//false
		Integer a=127;
		Integer b=127;
		System.out.println(a==b);//true
		//因为数值在byte（-128,127）范围内，对于新特性，如果该数已经存在，则不会开辟新空间。
	}
}