Java基础学习(三)—面向对象(上)

一、理解面向对象

      面向对象是一种思想，是基于面向过程而言的，就是说面向对象是将功能等通过对象来实现，将功能封装进对象之中，让对象去实现具体的细节；这种思想是将数据作为第一位，而方法或者说是算法作为其次，这是对数据一种优化，操作起来更加的方便，简化了过程。

     面向对象的三大特征: 封装性、继承性、多态性。

     封装性: 隐藏了对象的属性和实现细节，仅对外提供公共的访问方式，提高了代码的复用性和安全性。

     继承性: 两种事物之间存在一定的所属关系，那么继承的类可以从被继承的类中获得一些属性和方法，提高了代码的复用性。

     多态性: 父类的引用指向了子类对象，提高了程序的扩展性。多态有一点不好之处就是父类的引用不能访问子类中的成员。

 

二、成员变量和局部变量的区别

1.在类中的位置不同

     成员变量在类中的方法外定义的。

     局部变量在方法内或者方法声明上定义的。

 

2.在内存中的位置不同

     成员变量在堆内存中。

     局部变量在栈内存中。

 

3.生命周期不同

     成员变量随着对象的存在而存在，随着对象的消失而消失。

     局部变量随着方法的调用而存在，随着方法的调用完毕而消失。

 

4.初始化值不同

     成员变量有默认的初始化值。

     局部变量没有默认的初始化值，必须先定义、赋值后才能使用。

 

三、匿名对象

    定义: 没有名字的对象。

    两种使用情况:

                          A: 对象调用方法仅仅一次的时候。

                          B: 作为实际参数传递。

     好处: 匿名对象调用完毕就是垃圾，可以被垃圾回收器回收。

例子如下。

public class Test{

	public static void main(String[] args){

		//匿名对象调用方法
		new Student().show();

		//匿名对象作为实际参数传递
		new StudentDemo().method(new Student());
	}
}

class Student{
	public void show(){
		System.out.println("学生学习...");
	}
}

class StudentDemo{
	public void method(Student s){
		s.show();
	}
}

 

四、private关键字

     (1)是一个权限修饰符。

     (2)可以修饰成员变量和成员方法。

     (3)被private修饰的成员只在本类中才能访问。

应用如下。

public class Test{

	public static void main(String[] args){

		Student s = new Student();
		s.setName("Tom");
		s.setAge(22);

		System.out.println("name = " + s.getName());
		System.out.println("age = " + s.getAge());

	}
}

class Student{

	private String name;
	private int age;

	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name = name;
	}
	public int getAge(){
		return age;
	}
	public void setAge(int age){
		this.age = age;
	}
}

 

五、this关键字

     Java关键字this只能用于方法体内。当一个对象创建后，Java虚拟机就会为这个对象分配一个引用自身的指针，这个指针名字就是this。因此this只能在非静态方法中使用，静态方法和静态的代码块中绝对不可以出现this。this只和特点对象关联，而不和类关联，同一个类的不同对象有不同的this。

     this的使用有三种情况。

     1.函数的局部变量和成员变量同名情况下，成员变量被屏蔽，此时要访问成员变量则需要使用this.成员变量名的方式来引用成员变量。

public class Test{

	private int age = 10;

	public Test(int age){
		System.out.println("1---this.age = " + this.age);
		this.age = age;
		System.out.println("2---this.age = " + this.age);
	}

	public static void main(String[] args){
		Test t = new Test(22);
		System.out.println("age = " + t.age);
	}
}

结果:

      1---this.age = 10

      2---this.age = 22

      age = 22

 

2.在同一类中，可以用this调用其他构造方法。

class Student{

	private String username;
	private String password;
	private int age;

	public Student(String username,String password,int age){
		super();
		this.username = username;
		this.password = password;
		this.age = age;
	}

	public Student(String username,String password){
		this(username,password,0);
	}

	public Student(String username){
		this(username,"1234");
	}
}

 

3.在方法中，需要引用该方法所属类的当前对象的时候，使用this。

 

六、构造方法

1.作用

     给对象的数据进行初始化。

 

2.格式

     (1)方法名与类名相同。

     (2)没有返回值，连void都没有。

 

3.注意事项

     (1)如果你不提供构造方法，系统会给出默认无参构造方法。

     (2)如果你提供构造方法，系统将不再提供。

     (3)构造方法也是可以重载的。

 

public class Test{

	public static void main(String[] args){

		Student s = new Student("Tom",22);
		System.out.println("name = " + s.getName());
		System.out.println("age = " + s.getAge());
	}
}

class Student{

	private String name;
	private int age;

	public Student(){

	}

	public Student(String name,int age){
		this.name = name;
		this.age = age;
	}

	public String getName(){
		return name;
	}

	public void setName(String name){
		this.name = name;
	}

	public int getAge(){
		return age;
	}

	public void setAge(int age){
		this.age = age;
	}
}

 

Student s = new Student();在内存中做了什么事情？

(1)加载Student.class文件进内存。

(2)在栈内存为s开辟空间。

(3)在堆内存为学生对象开辟空间。

(4)对学生对象的成员变量进行默认初始化。

(5)对学生对象的成员变量进行显示初始化。

(6)通过构造方法对学生对象的成员变量赋值。

(7)学生对象初始化完毕，把对象地址赋值给s变量。

 

七、static关键字

 

1.特点

     (1)随着类的加载而加载。

     (2)优先于对象存在。

     (3)被类的所有对象共享。

     (4)可以通过类名直接调用。

 

2.static方法

     static方法一般称为静态方法。由于静态方法不依赖于任何对象就可以访问，因此在静态方法来说是没有this关键字的。而且在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法和非静态成员变量必须依赖具体的对象才能够被调用。但是注意，虽然在静态方法中不能访问非静态的成员变量和方法，但是在非静态成员方法中可以访问静态成员变量和方法的。

 

3.static变量

静态变量和成员变量的区别？

(1)所属不同

     静态变量属于类。      

     成员变量属于对象。

(2)内存中的位置不同

     静态变量存储在方法区的静态区。

     成员变量存储在堆内存中。

(3)出现时间不同

     静态变量随着类的加载而加载，随着类的消失而消失。

     成员变量随着对象的创建而存在，随着对象的消失而消失。

(4)调用不同

     静态变量可以通过类名调用，也可以通过对象调用。

     成员变量只能通过对象调用。

 

八、代码块

     在Java中使用"{ }"括起来的代码被称为代码块。根据其位置和声明不同，可分为局部代码块，构造代码块，静态代码块，同步代码块。

1.局部代码块

     在方法中出现，限定变量的生命周期，及早释放，提供内存利用率。

 

2.构造代码块

    在类中方法外出现，多个构造方法中相同的代码存放在一起，每次调用构造都执行，并且优先于构造方法执行。

 

3.静态代码块

     在类中的方法外出现，并加上static修饰，用于给类进行初始化，在加载的时候就执行，并且只执行一次。

 

/*
 * 代码块
 * 	(1)用{}括起来的代码。
 * 	(2)分类：
 * 		A:局部代码块
 * 			用于限定变量的生命周期，及早释放，提高内存利用率。
 * 		B:构造代码块
 * 			把多个构造方法中相同的代码可以放到这里，每个构造方法执行前，首先执行构造代码块。
 * 		C:静态代码块
 * 			对类的数据进行初始化，仅仅只执行一次。
 * 	(3)静态代码块,构造代码块,构造方法的顺序问题?
 * 		静态代码块 > 构造代码块 > 构造方法
 */
public class CodeBlock{

	//静态代码块
	static{
		int a = 30;
		System.out.println(a);
	}

	//构造代码块
	{
		int a = 20;
		System.out.println(a);
	}

	public CodeBlock(){

		System.out.println("CodeBlock......");

	}

	public static void main(String[] args){

		CodeBlock cb = new CodeBlock();
		CodeBlock cb2 = new CodeBlock();

		//局部代码块
		{
			int x = 10;
			System.out.println(x);
		}

	}
}

结果:

      30

      20

      CodeBlock......

      20

      CodeBlock......

      10