黑马程序员_JavaSE基础知识总结七：new、this、static关键字和单例模式初步
2015-11-13 00:12
681 查看
------ android培训、java培训、期待与您交流！
----------
一、new关键字
以”Person p = new Person( )”为例，创建一个对象都在内存中做了什么事情？
1：先将硬盘上指定位置的Person.class文件加载进内存。
2：执行main方法时，在栈内存中开辟了main方法的空间(压栈-进栈)，然后在main方法的栈区分配了一个变量p。
3：在堆内存中开辟一个实体空间，分配了一个内存首地址值。
4：在该实体空间中进行属性的空间分配，并进行了默认初始化。
5：对空间中的属性进行显示初始化。
6：进行实体的构造代码块初始化。
7：调用该实体对应的构造函数，进行构造函数初始化。
8：将首地址赋值给p ，p变量就引用了该实体。(指向了该对象)
二、this关键字
this 关键字指的是当前调用的对象，如果有100 个对象，将有100 个this 对象指向各个对象
this 关键字可以使用在：
①当局部变量和成员变量重名的时候可以使用this 指定调用成员变量；②通过this 调用另一个构造方法。
以下为具体实例：
1.当局部变量和成员变量重名的时候可以使用this 指定调用成员变量
<span style="font-size:18px;">public class OOTest09 {
public static void main(String[] args) {
Student zhangsan = new Student();
zhangsan.setId(1001);
zhangsan.setName("张三");
zhangsan.setSex(true);
zhangsan.setAddress("北京");
zhangsan.setAge(20);
System.out.println("id=" + zhangsan.getId());
System.out.println("name=" + zhangsan.getName());
System.out.println("sex=" + zhangsan.getSex());
System.out.println("address=" + zhangsan.
4000
getAddress());
System.out.println("age=" + zhangsan.getAge());
}
}
class Student {
// 学号
private int id;
// 姓名
private String name;
// 性别
private boolean sex;
// 地址
private String address;
// 年龄
private int age;
// 设置学号
public void setId(int id) {
this.id = id;
}
// 读取学号
public int getId() {
return id;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setSex(boolean sex) {
this.sex = sex;
}
public boolean getSex() {
return sex;
}
public void setAddress(String address) {
this.address = address;
}
public String getAddress() {
return address;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
}</span>
通过this 可以取得当前调用对象，采用this 明确指定了成员变量的名称，所以就不会赋值到局部变量，这里涉及到了狭义和广义上的javabean 概念，在这里不详述。
2.通过this 调用另一个构造方法
①通过new 调用当前对象的构造函数（注意这样是不对的）
<span style="font-size:18px;">public class OOTest10 {
public static void main(String[] args) {
// Student zhangsan = new Student(1001, "张三", true, "北京", 20);
// Student zhangsan = new Student(1001, "张三");
Student zhangsan = new Student(1002, "李四");
System.out.println("id=" + zhangsan.getId());
System.out.println("name=" + zhangsan.getName());
System.out.println("sex=" + zhangsan.getSex());
System.out.println("address=" + zhangsan.getAddress());
System.out.println("age=" + zhangsan.getAge());
}
}
class Student {
// 学号
private int id;
// 姓名
private String name;
// 性别
private boolean sex;
// 地址
private String address;
// 年龄
private int age;
public Student(int id, String name) {
/*
* this.id = id; this.name = name; this.sex=true; this.address="北京";
* this.age=20;
*/
// 调用构造函数,部分值采用默认值
new Student(id, name, true, "北京", 20);
}
public Student(int id, String name, boolean sex, String address, int age) {
this.id = id;
this.name = name;
this.sex = sex;
this.address = address;
this.age = age;
}
// 设置学号
public void setId(int studentId) {
id = studentId;
}
// 读取学号
public int getId() {
return id;
}
public void setName(String studentName) {
name = studentName;
}
public String getName() {
return name;
}
public void setSex(boolean studentSex) {
sex = studentSex;
}
public boolean getSex() {
return sex;
}
public void setAddress(String studentAddress) {
address = studentAddress;
}
public String getAddress() {
return address;
}
public void setAge(int studentAge) {
if (studentAge >= 0 && studentAge <= 120) {
age = studentAge;
}
}
public int getAge() {
return age;
}
}</span>
②通过this 调用当前对象的构造函数
<span style="font-size:18px;">public class OOTest11 {
public static void main(String[] args) {
Student zhangsan = new Student(1002, "李四");
System.out.println("id=" + zhangsan.getId());
System.out.println("name=" + zhangsan.getName());
System.out.println("sex=" + zhangsan.getSex());
System.out.println("address=" + zhangsan.getAddress());
System.out.println("age=" + zhangsan.getAge());
}
}
class Student {
// 学号
private int id;
// 姓名
private String name;
// 性别
private boolean sex;
// 地址
private String address;
// 年龄
private int age;
public Student(int id, String name) {
/*
* this.id = id; this.name = name; this.sex=true; this.address="北京";
* this.age=20;
*/
// 调用构造函数,部分值采用默认值
// new Student(id, name, true, "北京", 20);
// 采用this 调用当前对象对象的构造函数，不能采用new,以上调用是错误的
this(id, name, true, "北京", 20);
}
public Student(int id, String name, boolean sex, String address, int age) {
this.id = id;
this.name = name;
this.sex = sex;
this.address = address;
this.age = age;
}
// 设置学号
public void setId(int studentId) {
id = studentId;
}
// 读取学号
public int getId() {
return id;
}
public void setName(String studentName) {
name = studentName;
}
public String getName() {
return name;
}
public void setSex(boolean studentSex) {
sex = studentSex;
}
public boolean getSex() {
return sex;
}
public void setAddress(String studentAddress) {
address = studentAddress;
}
public String getAddress() {
return address;
}
public void setAge(int studentAge) {
if (studentAge >= 0 && studentAge <= 120) {
age = studentAge;
}
}
public int getAge() {
return age;
}
}</span>
注意：用this调用构造函数，必须定义在构造函数的第一行。因为构造函数是用于初始化的，所以初始化动作一定要执行。否则编译失败。
三、Static关键字
1、特点
①static 修饰符可以修饰：变量、方法和代码块
②想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。
③被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。
④静态随着类的加载而加载。而且优先于对象存在。
2、弊端
①有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。
②静态方法只能访问静态成员，不可以访问非静态成员。
因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。
③静态方法中不能使用this，super关键字。
因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。
④主函数是静态的。
3、成员变量和静态变量的区别
①成员变量所属于对象，所以也称为实例变量；静态变量所属于类，所以也称为类变量。
②成员变量存在于堆内存中，静态变量存在于方法区中。
③成员变量随着对象创建而存在，随着对象被回收而消失；静态变量随着类的加载而存在，随着类的消失而消失。
④成员变量只能被对象所调用 ，静态变量可以被对象调用，也可以被类名调用。
所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据。
那么什么时候定义静态成员呢？或者说：定义成员时，到底需不需要被静态修饰呢？
成员分两种：
①成员变量。（数据共享时静态化）
该成员变量的数据是否是所有对象都一样？如果是，那么该变量需要被静态修饰，因为是共享的数据。 如果不是，那么就说这是对象的特有数据，要存储到对象中。
②成员函数。（方法中没有调用特有数据时就定义成静态）
如何判断成员函数是否需要被静态修饰呢？
只要参考该函数内是否访问了对象中的特有数据即可：如果有访问特有数据，那方法不能被静态修饰，如果没有访问过特有数据，那么这个方法需要被静态修饰。
4、注意事项
①静态的生命周期很长；②静态代码块只执行一次（new 多个对象就只执行一次）。③静态代码块、构造代码块、构造函数同时存在时的执行顺序：静态代码块——构造代码块——构造函数。④静态代码块如果和主函数在同一类中，优先于主函数执行。
5、关于主函数的说明
Public：访问权限最大。
static：不需要对象，直接类名即可。
void：主函数没有返回值。
Main：主函数特定的名称。
(String[] args)：主函数的参数，是一个字符串数组类型的参数，jvm调用main方法时，传递的实际参数是 new String[0]。
jvm默认传递的是长度为0的字符串数组，我们在运行该类时，也可以指定具体的参数进行传递。可以在控制台，运行该类时，在后面加入参数。参数之间通过空格隔开。jvm会自动将这些字符串参数作为args数组中的元素，进行存储。
四、单例模式初步
设计模式是可以重复利用的解决方案，设计模式的提出是在1995 年，是由4 位作者提出的，称为GoF,也就是“四人组”提出的。
设计模式从结构上分为三类：创建型、结构性、行为型。
其中最简单的设计模式就是单例了，单例这种模式，尽量少用，也有将其称为“反模式”。
我们知道对象实例创建完成后，会放到堆中，如果堆中的实例过多，将会存在特别多的垃圾，这样会导致一些问题，如内存溢出等，使用单例模式后，只会创建一个实例，显著减少对象实例的个数，同时也会提高性能，因为不会频繁的创建对象，这只是他的一个好处，初学者只需要了解这方面即可。
单例模式的三要素：
①在类体中需要具有静态的私有的本类型的变量；
②构造方法必须是私有的；
③提供一个公共的静态的入口点方法。
<span style="font-size:18px;">public class SingletonPatternTest01 {
public static void main(String[] args) {
// Singleton s1 = new Singleton();
// Singleton s2 = new Singleton();
// ............
Singleton.getInstance().test();
}
}
class Singleton {
// 静态私有的本类的成员变量
private static Singleton instance = new Singleton();
// 私有的构造方法
private Singleton() {
}
// 提供一个公共的静态的入口点方法
public static Singleton getInstance() {
return instance;
}
public void test() {
System.out.println("----------test----------");
}
}</span>
----------
一、new关键字
以”Person p = new Person( )”为例，创建一个对象都在内存中做了什么事情？
1：先将硬盘上指定位置的Person.class文件加载进内存。
2：执行main方法时，在栈内存中开辟了main方法的空间(压栈-进栈)，然后在main方法的栈区分配了一个变量p。
3：在堆内存中开辟一个实体空间，分配了一个内存首地址值。
4：在该实体空间中进行属性的空间分配，并进行了默认初始化。
5：对空间中的属性进行显示初始化。
6：进行实体的构造代码块初始化。
7：调用该实体对应的构造函数，进行构造函数初始化。
8：将首地址赋值给p ，p变量就引用了该实体。(指向了该对象)
二、this关键字
this 关键字指的是当前调用的对象，如果有100 个对象，将有100 个this 对象指向各个对象
this 关键字可以使用在：
①当局部变量和成员变量重名的时候可以使用this 指定调用成员变量；②通过this 调用另一个构造方法。
以下为具体实例：
1.当局部变量和成员变量重名的时候可以使用this 指定调用成员变量
<span style="font-size:18px;">public class OOTest09 {
public static void main(String[] args) {
Student zhangsan = new Student();
zhangsan.setId(1001);
zhangsan.setName("张三");
zhangsan.setSex(true);
zhangsan.setAddress("北京");
zhangsan.setAge(20);
System.out.println("id=" + zhangsan.getId());
System.out.println("name=" + zhangsan.getName());
System.out.println("sex=" + zhangsan.getSex());
System.out.println("address=" + zhangsan.
4000
getAddress());
System.out.println("age=" + zhangsan.getAge());
}
}
class Student {
// 学号
private int id;
// 姓名
private String name;
// 性别
private boolean sex;
// 地址
private String address;
// 年龄
private int age;
// 设置学号
public void setId(int id) {
this.id = id;
}
// 读取学号
public int getId() {
return id;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setSex(boolean sex) {
this.sex = sex;
}
public boolean getSex() {
return sex;
}
public void setAddress(String address) {
this.address = address;
}
public String getAddress() {
return address;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
}</span>
通过this 可以取得当前调用对象，采用this 明确指定了成员变量的名称，所以就不会赋值到局部变量，这里涉及到了狭义和广义上的javabean 概念，在这里不详述。
2.通过this 调用另一个构造方法
①通过new 调用当前对象的构造函数（注意这样是不对的）
<span style="font-size:18px;">public class OOTest10 {
public static void main(String[] args) {
// Student zhangsan = new Student(1001, "张三", true, "北京", 20);
// Student zhangsan = new Student(1001, "张三");
Student zhangsan = new Student(1002, "李四");
System.out.println("id=" + zhangsan.getId());
System.out.println("name=" + zhangsan.getName());
System.out.println("sex=" + zhangsan.getSex());
System.out.println("address=" + zhangsan.getAddress());
System.out.println("age=" + zhangsan.getAge());
}
}
class Student {
// 学号
private int id;
// 姓名
private String name;
// 性别
private boolean sex;
// 地址
private String address;
// 年龄
private int age;
public Student(int id, String name) {
/*
* this.id = id; this.name = name; this.sex=true; this.address="北京";
* this.age=20;
*/
// 调用构造函数,部分值采用默认值
new Student(id, name, true, "北京", 20);
}
public Student(int id, String name, boolean sex, String address, int age) {
this.id = id;
this.name = name;
this.sex = sex;
this.address = address;
this.age = age;
}
// 设置学号
public void setId(int studentId) {
id = studentId;
}
// 读取学号
public int getId() {
return id;
}
public void setName(String studentName) {
name = studentName;
}
public String getName() {
return name;
}
public void setSex(boolean studentSex) {
sex = studentSex;
}
public boolean getSex() {
return sex;
}
public void setAddress(String studentAddress) {
address = studentAddress;
}
public String getAddress() {
return address;
}
public void setAge(int studentAge) {
if (studentAge >= 0 && studentAge <= 120) {
age = studentAge;
}
}
public int getAge() {
return age;
}
}</span>
②通过this 调用当前对象的构造函数
<span style="font-size:18px;">public class OOTest11 {
public static void main(String[] args) {
Student zhangsan = new Student(1002, "李四");
System.out.println("id=" + zhangsan.getId());
System.out.println("name=" + zhangsan.getName());
System.out.println("sex=" + zhangsan.getSex());
System.out.println("address=" + zhangsan.getAddress());
System.out.println("age=" + zhangsan.getAge());
}
}
class Student {
// 学号
private int id;
// 姓名
private String name;
// 性别
private boolean sex;
// 地址
private String address;
// 年龄
private int age;
public Student(int id, String name) {
/*
* this.id = id; this.name = name; this.sex=true; this.address="北京";
* this.age=20;
*/
// 调用构造函数,部分值采用默认值
// new Student(id, name, true, "北京", 20);
// 采用this 调用当前对象对象的构造函数，不能采用new,以上调用是错误的
this(id, name, true, "北京", 20);
}
public Student(int id, String name, boolean sex, String address, int age) {
this.id = id;
this.name = name;
this.sex = sex;
this.address = address;
this.age = age;
}
// 设置学号
public void setId(int studentId) {
id = studentId;
}
// 读取学号
public int getId() {
return id;
}
public void setName(String studentName) {
name = studentName;
}
public String getName() {
return name;
}
public void setSex(boolean studentSex) {
sex = studentSex;
}
public boolean getSex() {
return sex;
}
public void setAddress(String studentAddress) {
address = studentAddress;
}
public String getAddress() {
return address;
}
public void setAge(int studentAge) {
if (studentAge >= 0 && studentAge <= 120) {
age = studentAge;
}
}
public int getAge() {
return age;
}
}</span>
注意：用this调用构造函数，必须定义在构造函数的第一行。因为构造函数是用于初始化的，所以初始化动作一定要执行。否则编译失败。
三、Static关键字
1、特点
①static 修饰符可以修饰：变量、方法和代码块
②想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。
③被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。
④静态随着类的加载而加载。而且优先于对象存在。
2、弊端
①有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。
②静态方法只能访问静态成员，不可以访问非静态成员。
因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。
③静态方法中不能使用this，super关键字。
因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。
④主函数是静态的。
3、成员变量和静态变量的区别
①成员变量所属于对象，所以也称为实例变量；静态变量所属于类，所以也称为类变量。
②成员变量存在于堆内存中，静态变量存在于方法区中。
③成员变量随着对象创建而存在，随着对象被回收而消失；静态变量随着类的加载而存在，随着类的消失而消失。
④成员变量只能被对象所调用 ，静态变量可以被对象调用，也可以被类名调用。
所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据。
那么什么时候定义静态成员呢？或者说：定义成员时，到底需不需要被静态修饰呢？
成员分两种：
①成员变量。（数据共享时静态化）
该成员变量的数据是否是所有对象都一样？如果是，那么该变量需要被静态修饰，因为是共享的数据。 如果不是，那么就说这是对象的特有数据，要存储到对象中。
②成员函数。（方法中没有调用特有数据时就定义成静态）
如何判断成员函数是否需要被静态修饰呢？
只要参考该函数内是否访问了对象中的特有数据即可：如果有访问特有数据，那方法不能被静态修饰，如果没有访问过特有数据，那么这个方法需要被静态修饰。
4、注意事项
①静态的生命周期很长；②静态代码块只执行一次（new 多个对象就只执行一次）。③静态代码块、构造代码块、构造函数同时存在时的执行顺序：静态代码块——构造代码块——构造函数。④静态代码块如果和主函数在同一类中，优先于主函数执行。
5、关于主函数的说明
Public：访问权限最大。
static：不需要对象，直接类名即可。
void：主函数没有返回值。
Main：主函数特定的名称。
(String[] args)：主函数的参数，是一个字符串数组类型的参数，jvm调用main方法时，传递的实际参数是 new String[0]。
jvm默认传递的是长度为0的字符串数组，我们在运行该类时，也可以指定具体的参数进行传递。可以在控制台，运行该类时，在后面加入参数。参数之间通过空格隔开。jvm会自动将这些字符串参数作为args数组中的元素，进行存储。
四、单例模式初步
设计模式是可以重复利用的解决方案，设计模式的提出是在1995 年，是由4 位作者提出的，称为GoF,也就是“四人组”提出的。
设计模式从结构上分为三类：创建型、结构性、行为型。
其中最简单的设计模式就是单例了，单例这种模式，尽量少用，也有将其称为“反模式”。
我们知道对象实例创建完成后，会放到堆中，如果堆中的实例过多，将会存在特别多的垃圾，这样会导致一些问题，如内存溢出等，使用单例模式后，只会创建一个实例，显著减少对象实例的个数，同时也会提高性能，因为不会频繁的创建对象，这只是他的一个好处，初学者只需要了解这方面即可。
单例模式的三要素：
①在类体中需要具有静态的私有的本类型的变量；
②构造方法必须是私有的；
③提供一个公共的静态的入口点方法。
<span style="font-size:18px;">public class SingletonPatternTest01 {
public static void main(String[] args) {
// Singleton s1 = new Singleton();
// Singleton s2 = new Singleton();
// ............
Singleton.getInstance().test();
}
}
class Singleton {
// 静态私有的本类的成员变量
private static Singleton instance = new Singleton();
// 私有的构造方法
private Singleton() {
}
// 提供一个公共的静态的入口点方法
public static Singleton getInstance() {
return instance;
}
public void test() {
System.out.println("----------test----------");
}
}</span>
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 合格的PHP程序员必备技能
- 提高程序员工作效率11招让你远离加班
- 武汉软件工程职业学院与传智播客签约达成深度校企合作
- 百度外卖面试记录
- 黑马程序员_JavaSe基础知识总结六：super、final关键字
- 黑马程序员_JavaSE基础知识总结五：类与对象的区分及封装特性
- 北京某互联网支付公司的面试要求(Android)
- 前端面试
- 黑马程序员——Java基础---集合
- 今天参加面试 上机题，整理一下
- 总结CSS面试题目的考察点及常见布局问题整理
- ——黑马程序员——OC中简单单列模式的实现
- JAVA面试题
- 软件开发工程师面试题目
- 程序员面试经典题--归并排序
- 黑马程序员——正则表达式
- 转载：java面试题(二)
- java程序员第一课 html 网页标签
- 转载：java面试题(一)
- SDCC 2015讲师专访精彩集锦：程序员界“香饽饽”、大神级人物都在！