Java_面向对象(上)

内容概述

• 类的概念
• 类的定义
• 对象的使用
• 方法的形参
• 匿名对象
• 封装
• private关键字
• this关键字
• 构造方法
• static关键字
• 静态变量和成员变量的区别

类的概念

类：是一组相关的"属性"和"行为"的集合；

对象：是该类事物的具体体现；

类的定义

1.使用关键字：class(注意小写)

2.一个java源文件中：

1).如果定义多个类，但只有一个是public的；而且源文件名必须与这个public的类名一致；

2).如果定义多个类，可以没有public类；源文件名没有一致性要求；

3).main()方法不是必须放在public类中；

3.类中可以定义什么：

1).成员变量：

A.可以是基本数据类型，也可以是任何引用数据类型；

B.可以显示初始化；

class Student{
	String name = "张三" ;
	int age = 20;
}

C.可以隐式初始化；

整型：0
浮点：0.0
字符：'\u0000'
布尔：false
引用类型：null

2).成员方法：

A.可以有参数，可以没参数；可以有返回值，可以没有返回值；
B.方法的"形参"可以是任何Java类型(基本数据类型、引用数据类型)
C.方法的"返回值"可以是任何Java类型(基本数据类型、引用数据类型)
D.一个类中可以定义多个同名的方法，但形参列表不完全相同，叫：方法的重载；

3).内部类；

4.成员变量和局部变量的区别：

1).成员变量：

A.定义在"类体"中；可以是任何数据类型；

B.会被自动初始化；

class Student{
	String name;
	void show(){
		System.out.println("我叫：" + name);	//打印：我叫：null
	}
}

C.当实例化对象后，被存储在"堆"中；

D.当"对象"不被使用(没有任何引用)，并被垃圾回收器回收时被清理；

E.定义后，即使不赋初始值，也可以直接访问。因为JVM会自动赋初始值：

整数：0
小数：0.0
字符：'\u0000'
布尔：false
引用类型：null

2).局部变量：

A.定义在某个方法、或其它代码块中；

B.必须显示初始化，否则不能访问其值；

class Student{
	void show(){
		String name;
		System.out.println("我叫：" + name);	//编译错误。局部变量必须显示初始化才能访问其值；
		name = "张三";	//OK。可以被赋值。
	}
}

C.当方法或其它代码块被执行时，基本数据类型的"值"和引用数据类型的"引用"都是存储在"栈"中；

D.当方法或代码块执行完毕时，会被立即清理；

对象的使用

1.创建对象使用new关键字；会在堆中分配内存空间；

格式：类名 变量名 = new 类名();

2.一个类可以创建多个对象；

3.每个“对象”的“成员变量”在"堆"中都有一份独立的空间；

   每个“对象”的“成员方法”被存储在“方法区”中，多个对象只有一个“方法空间”；  

4.对象的"引用(地址)"被存储在"栈"中；

方法的形参

1.可以是"基本数据类型"：

1).调用时，必须传递此类型的“值”；

2).调用时，是将值复制一份到方法内部；

3).在方法内，使用形参接收此值的副本；

4).在方法内，如果更改此值，对原值没有影响；

int a = 10;
show(a);
System.out.println(a);//10
----------------------------------
public void show(int n){//n = 10
	n = 20;//对原来的a的值是没有影响的；
}	

2.可以是“引用数据类型”：

1).调用时，必须传递此类型的“引用”；

2).调用时，是将“引用(地址)”复制一份到方法内部；

3).在方法内，使用形参接收此“引用”的副本；

4).在方法内，如果通过此引用更改堆中的值，对原堆中的值将会产生影响；

int[] arr = {14,324,435};//arr = 0x2233
show(arr);//show(0x2233)
System.out.println(arr[0]);//1000
-----------------------------------
public void show(int[] array){//array = 0x2233
	array[0] = 1000;
}

匿名对象

1.匿名对象：没有名字的对象：new Student();

2.匿名对象的两种使用情况：

1).对象调用方法仅仅一次的时候:new Student().show();
2).作为实际参数传递:printStudent(new Student());

封装

1.直接对外部暴露成员变量是很不安全的，这时可以将成员变量“私有化”，对外提供公有的get和set方法；

2.封装的好处：

1)隐藏实现细节，提供公共的访问方式

2)提高了代码的复用性

3)提高安全性。

3.封装的原则：

1)将不需要对外提供的内容都隐藏起来。

2)把属性隐藏，提供公共方法对其访问。

private关键字

1.是一种“访问修饰符”:
  Java中一共有四种访问修饰符：从宽到窄：public，protected，(默认)，private

2.用于修饰“成员变量”和“成员方法”；

3.被private修饰的成员，只能在类的内部被其它成员访问。在类外部无法访问；

this关键字

1.每个类都有一个“隐式”的变量：this；

2.它是在实例化对象时，由虚拟机自动赋值的，会被自动赋值为当前对象的“引用”。
                  所以每个对象内的this变量的值是不同的；

3.this关键字可以调用本对象的“成员属性”、“成员方法”、“构造方法”；

4.以下情况必须显示的使用this：

1).“局部变量”覆盖“成员变量”时，可以使用this显示的访问被覆盖的“成员变量”；否则访问的是“局部变量”；

2).在一个构造方法中调用本类的其它构造方法；this()或this(实参)；

构造方法

1.当实例化一个类的对象时，JVM会自动调用本类的一个方法：构造方法；

2.定义类时，可以不定义构造方法，编译器会自动添加一个无参，什么都不做的构造方法；

3.如果类中定义了构造方法，编译器就不会添加任何构造方法了；

4.构造方法的格式要求：

1)."方法名"：构造方法名必须与类名一致；

2)."返回值类型"：构造方法不能定义“返回值类型”，甚至是void；

3).构造方法不能返回一个具体的值，但内部可以使用return;语句；

4)."形参" : 可以有，可以没有。如果没有形参，小括号一定要写。

注意：

1).以下代码可以编译通过：

class Student{
	public void Student(){	//普通成员方法，不是构造方法；
	}
}

2).以下代码不能通过编译：

class Student{
	public student(){	//构造方法必须同类名一致，包括大小写；
	}
}

5.构造方法的重载：

1).构造方法是可以重载的：一个类中，可以定义多个构造方法。但形参列表不能完全相同；

2).构造方法中"形参"的作用：一般是用来初始化"成员变量"。

3).构造方法重载的意义：
方便程序员使用此类，在构造此类的对象时，非常的方便灵活。
--如果构造时有数据时，可以调用"带参"的构造方法，可以直接为成员属性赋值；
  后期无需再调用set方法为成员属性赋值；
--如果构造时没有数据，也可以调用"无参"的构造方法；后期再通过调用set方法
  为成员属性赋值；

4).注意：当我们定义了某个构造方法后，编译器将不会为我们的类添加任何的构造方法；

5).在一个构造方法中可以调用另一个构造方法，使用this关键字；

6).构造方法可以调用“成员方法”，但“成员方法”不能调用构造方法；构造方法也可以调用其它构造方法；

构造方法的注意事项：

当我们定义了某个构造方法后，编译器将不会为我们的类添加任何的构造方法；

static关键字

1.Java中为我们提供了一种机制，可以避免每个对象都存储相同的变量值，这种机制就是：static（静态的、全局的）

2.可以修饰“成员变量”和“成员方法”。被static修饰的成员变量存储在方法区的“静态存储区”，只有一份拷贝，被多个对象共享；

3.特点：

1).随着类的加载而加载
2).优先于对象存在
3).被类的所有对象共享
4).可以通过类名调用，也可以通过对象名调用；

4.static关键字注意事项：

1).在静态方法中是没有this关键字的
2).静态方法只能访问静态的成员变量和静态的成员方法
3).普通成员方法：可以访问静态的，也可以访问普通的；

5.static可以修饰：

1).成员变量：表示"静态变量(全局变量)"，存储在"方法区--静态存储区"，只有一个存储空间，被多个对象共享；
2).成员方法：表示"静态方法"，存储在"方法区--静态存储区"，只有一个存储空间，被多个对象共享；

eg:

java.lang.Math:Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

public static double random():此方法可以返回一个大于或等于0.0，并且小于1.0的随机数

class Demo01 
{
	public static void main(String[] args) 
	{
		for(int i = 0;i < 10 ;i++){
			System.out.println("获取一个随机数：" + Math.random());//范围：0--0.9999999....
		}
		//生成一个1--10的数:(int)(Math.random() * 10) + 1
		for(int i = 0;i < 10 ; i++){
			System.out.println("获取一个1--10的随机数：" + ((int)(Math.random() * 10) + 1));
		}
	}
}

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

1.所属不同

1).静态变量属于类，所以也称为为类变量

2).成员变量属于对象，所以也称为实例变量(对象变量)

2.内存中位置不同

1).静态变量存储于方法区的静态区

2).成员变量存储于堆内存

3.内存出现时间不同

1).静态变量随着类的加载而加载，随着类的消失而消失

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

4.调用不同

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

2).成员变量只能通过对象名调用