Java面向对象（二）--总结完整精彩的你必看的Java文章

一、 匿名对象

直接new
语法：
new 类();
示例：
public class Business
{
public void show()
{
System.out.println(“This is show”);
}
public static void main(String[] args)
{
new Business().show();
}

}

二、全局变量和局部变量

全局变量：属性就是全局变量又叫成员变量
局部变量：定义在大括号内的变量就是局部变量

成员变量和局部变量的区别
1、作用域不同
局部变量的作用域仅限于定义它的方法或者代码块
成员变量的作用域在整个类内部都是可见的

2、初始值不同
Java会给成员变量一个初始值
引用数据类型：null
char ‘\u0000’
int 0
float 0.0f;
double 0.0d;
long 0L
boolean false
Java不会给局部变量赋予初始值

3、在同一个方法中，不允许有同名局部变量；在不同的方法中，可以有同名局部变量

4、两类变量同名时，局部变量具有更高的优先级
5、他们在内存中存在的区域不一样
成员变量存在于堆内存的对象中
局部变量存在于栈内存的方法中
6、有关初始值的区别
成员变量都有默认的初始值
局部变量没有默认的初始值，定以后必须给初始值
三、方法和方法之间的调用

1、对象本身的普通方法
(1)类内部的方法
直接调用
示例：
public class Machine {

public void show()
{   
	test();
	System.out.println("This is show");
}
public void test()
{
	System.out.println("This is test");
}
public static void main(String[] args) {
     Machine m = new Machine();
     m.show();
}

}
（2）不同类之间的方法
首先生成对方个实例，通过实例调用
public class Machine {

public void show()
{   
	B b=new B();
	b.test();
	System.out.println("This is show");
}

}
class B{
public void test()
{
System.out.println(“This is test”);
}

}
2、带static的方法
(1)static方法调用static方法
直接调用
public class Machine
{
public static void show()
{
System.out.println(“This is show”);
}
public static void main(String[] args) {
show();
}
}
（2）非static方法调用static方法
可以直接调用
public class Machine
{
public static void show()
{
System.out.println(“This is show”);
}
public void test()
{
show();
}
}
（3）static方法调用非static方法
不能直接调用，必须经过实例化
public class Machine
{
public static void show()
{
Machine m=new Machine();
m.test();
}
public void test()
{
System.out.println(“This is show”);
}
}

四、对象在内存中的体现
为了对数据方便的管理就好像对房间进行方便管理一样，我们内存划分区域。对内存区域的划分历来有争议，这里参考些比较有权威的资料给大家解释下。对于开发人员来说一般我们将内存划分为栈、堆、静态共享区、方法区等
栈：
存放：局部变量
先进后出，自下而上存储
方法执行完毕，自动释放空间
堆：
存放new出来的对象
需要垃圾回收器来回收
静态共享区：
存放： static变量等
1、对象的产生
例如：有Person类
public class Person
{
int age;
void show()
{
System.out.println(“I am “ + age);
}
}
Person p1 = new Person();执行完后的内存状态

当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。除了基本数据类型之外的都是变量类型都是引用类型，如上面的Person及前面讲过的数组

2、对象的使用
创建新的对象之后我们就可以使用“ 对象名.对象成员 ”的格式来访问对象的员

class Test
{
public static void main(String[] args)
{
Person p1 = new Person();
Person p2 = new Person();
p1.age = 20;
p1.show();
p2.show();
}
}
上述代码运行的内存示意图如下：

3、对象的回收

下面举2个例子详细说明对象的生命周期：
例-1：
public class Test
{
public static void change(int i)
{
i=1;
}
public static void main(String args[]) {
int i=0;
change(i);
System.out.println(i);
}
}

说明：
i=0进栈，然后 i=0出栈，i=1,i=1出栈，方法运行完毕，出栈，方法默认含有return结束方法体，声明周期结束，这时候只有主方法i=0
例-2：
public class Test
{
int i=10;
public static void change(Test t)
{
t.i=100;
}
public static void main(String args[])
{
Test t=new Test();
t.i=1000;
change(t);//将此代码改为change(new Test())结果有什么不同
System.out.println(t.i);
}
}

说明：
上述操作mian方法进栈；对象t进栈，并且在堆内存分配空间；对象t有个成员i,初始化为0，系统将10赋予I;这时候change方法进栈，change方法的t进栈，并指向堆中同一个地址0x00ff（假设值）这时候将i修改为100;方法出栈，内存中只剩下对象t

总结：
1、堆 ：new 出来的数据对象
2、栈 ： 局部变量的数据
3、数据共享区 ：static
注意：凡是new 出来的东西在堆区，是一个个新的对象。例如：
1、System.out.println(new Goods()new Goods());输出false
2、 System.out.println(new Goods());
System.out.println(new Goods());
输出hashCode不一样
test002.Goods@18a992f
test002.Goods@4f1d0d
3、下列5个对象不是同一个对象
for(int i=0;i<5;i++)
{
Goods lily=new Goods();
System.out.println(lily);
}
可以根据打印的对象的值来判断
test002.Goods@18a992f
test002.Goods@4f1d0d
test002.Goods@1fc4bec
test002.Goods@dc8569
test002.Goods@1bab50a
栈空间举例：
public class Goods
{
public static void main(String[] args)
{
Recursion r=new Recursion();
long num=r.fac(5);
System.out.println(num);
}
}
class Recursion{
public long fac(int n){
if(n1){
return 1;
}else{
return n*fac(n-1);
}
}
}

五、this关键字
（1）什么是this
this一般出现在方法的声明里面。this指的是当前对象，即代表使用该方法对象的那个引用，所以那个对象调用了this所在函数，this就代表那个对象
（2）this的用处
1、使用this处理方法中成员变量和局部变量、参数重名的情况，可以使程序更清晰
class Person
{
private String id;//身份证号
private String name;//姓名
//函数体里面不能写成name=name，所以使用this来区分成员变量和参数
Person(String name) {
this.name=name;
}
public void speak()
{
System.out.println(name+“在说话！”);
}
public static void main(String args[])
{
Person p=new Person(“张三”);
p.speak();
}
}
2、必须指出当前方法的对象是谁的时候要使用this
class Person
{
private String id;//身份证号
private String name;//姓名
//可以不显式使用this,但是当方法中的参数名和类的成员变量名一样时，可以使程序更清晰
public void setSpeak(String name)
{
this.name=name;
}
public String getSpeak()
{
return this.name;
}
public static void main(String args[])
{
Person p1=new Person();
p1.setSpeak(“张三”);
System.out.println(p1.getSpeak()+“在说话！”);
Person p2=new Person();
p2.setSpeak(“李四”);
System.out.println(p2.getSpeak()+“在说话！”);
}
}
3、在构造函数中调用其他构造函数。但是只能放在构造函数的第一行，因为初始化的动作要先执行
class Person
{
String name;
int age;
String sex;
public Person()
{
System.out.println(“构造器Person()被调用”);
sex =“Male”;
System.out.println(“name=”+name+" age="+age+" sex="+sex);
}
public Person(String theName)
{
//调用构造器Person()
this();
System.out.println(“构造器Person(String theName)被调用”);
this.name = theName;
System.out.println(“name=”+name+" age="+age+" sex="+sex);
}
public Person(String theName,int theAge)
{
//调用构造器Person(String theName)
this(theName);
System.out.println(“构造器Person(String theName,int theAge)被调用”);
age = theAge;
System.out.println(“name=”+name+" age="+age+" sex="+sex);
}

public String getName()
{
	return name;
}

public int getAge()
{
	return age;
}

public String getSex()
{
	return sex;
}	

}
4、将当前对象作为参数传递给其它方法或构造器
class Account
{
int accountId = 100;

public Account createAccount()
{
	accountId ++;
	return this;
}

public int getAccountId()
{
	return accountId;
}

public static void main(String[] args)
{
	Account a= new Account();
	System.out.println("账号是："+a.createAccount().getAccountId());
}	

}
六、包package和import关键字
1、为什么需要package?
为了解决类之间的重名问题；为了便于管理类：合适的类位于合适的包
2、package怎么用?
通常是类的第一句非注释性语句。
包名：域名倒着写即可，再加上模块名，并与内部管理类。
3、注意事项：
写项目时都要加包，不要使用默认包。com.gao和com.gao.car，这两个包没有包含关系，是两个完全独立的包。只是逻辑上看起来后者是前者的一部分
4、JDK中的主要包
java.lang
包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。
java.awt
包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。
java.net
包含执行与网络相关的操作的类。
java.io
包含能提供多种输入/输出功能的类。
java.util
包含一些实用工具类，如定义系统特性、使用与日期日历相关的函数
5、为什么需要import?
如果不适用import，我们如果用到其他包的类时，只能这么写：java.util.Date，代码量太大，不利于编写和维护。通过import可以导入其他包下面的类，从而可以在本类中直接通过类名来调用

import怎么使用?
import java.util.Date;
import java.util.*; //导入该包下所有的类。会降低编译速度，但不会降低运行速度。

注意要点：
java会默认导入java.lang包下所有的类，因此这些类我们可以直接使用。
如果导入两个同名的类，只能用包名+类名来显示调用相关类：
java.util.Date date = new java.util.Date();

静态导入的作用：用于导入指定类的静态属性
JDK5.0后增加！

import static：
import static java.lang.Math.*;//导入Math类的所有静态属性
import static java.lang.Math.PI;//导入Math类的PI属性
然后，我们可以在程序中直接使用：System.out.println(PI);
七、static关键字
（1）在类中，用static声明的成员变量为静态成员变量，它为该类的公用变量，对于该类的所有对象来说，staitic成员变量只有一个
（2）用static声明的方法为静态方法，在调用该方法时候，不会将对象的引用传递给它，所以在static方法中不可以访问非static成员，也就是说由于静态方法不再针对于某个对象的调用，所以不能访问非静态成员
被static修饰的成员有如下特点：
1、随着类的加载而加载
2、优先于对象存在
3、被所有对象共享
4、可以用类名直接调用：类名.static成员；类名.方法名()
注意：静态方法中不能写this、super关键字
静态变量和成员变量区别
（1）生命周期不同：成员变量随着对象的创建而存在，随着对象的销毁而释放静态变量随着类的加载而存在，随着类的消失而消失
（2）调用方式不一样：成员变量只能被类对象调用，静态变量可以被对象调用，也可以用类名调用
（3）成员变量是类实例化的变量，静态变量为类变量
（4）数据存储位置不同
成员变量存储在堆内存的对象中，是对象的特有数据；静态数据存储在内存数据共享区

静态代码：
class Test
{
static {………}//静态代码块
}
（1）、其特点为随着类的加载而执行，而且只执行一次
public class StaticTest
{
static
{
System.out.println(“this is static demo!”);
}
void test()
{
System.out.println(“this is test!”);
}
public static void main(String[] args)
{

   new StaticTest().test();
   new StaticTest().test();
}

}
其作用为类的成员初始化（有的类全是静态成员方法）
public class StaticTest1
{
static int num;
static
{
int num=0;
}
public static void f1()
{
System.out.println(num);
}
public static void f2()
{
System.out.println(num+1);
}
}
下列代码输出什么结果？为什么？
public class Demo {
public static String sname;
static{
sname=“lily”;
System.out.println(sname);
}
public Demo()
{
System.out.println(“这是构造方法”);
}
public static void main(String[] args) {
new Demo();
}
}
先有类，后有对象
补充知识点：代码块
public class Demo {
{
System.out.println(“这是代码块”);
}
public Demo()
{
System.out.println(“这是无参数构造方法”);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
new Demo();
}
}
总结：static > 代码块 > 构造函数；static不能修饰局部变量；static方法里面不能有this因为static和this属于不同的内存区域，this是对象没有实例化它不存在