Java类及类的成员

Java类及类的成员，属性、方法、构造器、代码块、内部类

类与对象

类（class)：是对一类事物的描述，是抽象的，概念上的定义。
对象（object）：是实际存在的该类事物的每个个体，也称实例。
面向对象程序设计的重点是类的设计；设计类，就是设计类的成员

一. 类的构成

①属性和方法
属性：对应类中的成员变量，声明在类的{ } 中；
方法：对应类中的成员方法（函数）method；
②类和对象的创建：创建类的对象=类的实例化=实例化类；

二. 类和对象的使用

①创建类，设计类成员
②创建类的对象
③通过对象.属性， 对象.方法，调用对象的结构

三.类和多个对象的关系

1.若创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性（非static）
意味着，修改一个对象的属性，不影响另一个对象的属性的值；
代码实例：

public class Csdn {
	public static void main(String[] args) {
		Person tom=new Person(); //创建Person类的对象tom
		int s=tom.age =18;  //调用属性赋值
		System.out.println("age:"+s);//输出
		Person tin=new Person(); //创建Person类的对象tin
		System.out.println("age:"+tin.age +"\t"+"name:"+tin.name );//输出
	}
}
	class Person{
		String name="Tony";//属性
		int age=20;
	}

四. 匿名对象的使用

1.概念：创建的对象，没有赋给一个变量名
2.特征：只能调用一次
3.使用

PhoneMe  me=new PhoneMe();
me.show(new Phone());
class PhoneMe{
	public void show(Phone phone){
	phone.sendEmail();
	phone.playGame();
	}

五.对象的内存解析

堆（Heap)：存放对象实例（通过new出来的结构 数组、对象等）非static的对象
虚拟机栈（Static):通常所说的栈，存放局部变量（方法中声明的，形参等）
方法区（Method area):存放类信息、常量、静态变量
（static域）、即时编译后的代码数据
内存解析例1

六.对象数组的内存解析

注：引用数据类型的变量，只可存储两类值 null 或是地址值（包含变量类型）

//随机生成五名学生的个人信息
public class Id {
	public static void main(String[] args) {
		Student[] stu=new Student[5];//定义数组
		for(int i=0;i<stu.length;i++) {
			stu[i]=new Student();//给每个元素创建对象
			stu[i].number =(int)(Math.random()*30+1);//生成随机数赋值
			stu[i].score=(int)(Math.random()*100);
			stu[i].state=(int)(Math.random()*7+1);
		}
		for(int i=0;i<stu.length;i++) {
			System.out.println( "学号："+stu[i].number+"  "+
		"年级："+stu[i].state+"成绩："+stu[i].score);
		}
	}
}
	class Student{
		int number;
		int state;
		int score;
	}

图示

类的结构

类的结构之一：属性

成员变量（属性）与局部变量的对比

一. 相同点
①定义变量的格式：数据类型 变量名=变量值；
②变量都有其对应的作用域

二. 不同点
① 声明位置
成员变量（属性）：直接定义在类的一对{ } 内；

class People{
String  name="tom";//属性
int age=19;
		}

局部变量：声明在方法内，方法 形参，代码块内，构造器形参及内部变量；
②权限修饰符的使用
成员变量（属性）：可以在声明属性时，指明其权限；
常用权限修饰符（private、public、缺省/友好（默认）、protected）
局部变量：不可使用权限修饰符
③默认初始化值
成员变量（属性）：类的属性，根据其数据类型，都有默认的初始化值；
整型（byte、short、int、long) : 0;
浮点型（float、double): 0.0;
字符型（char): 0 (或“\u0000");
布尔型（boolean): false;
引用数据类型(String、类、数组、接口）： null
局部变量：无默认初始化值，调用局部变量时，一定要显示赋值（初始化）形参调用时赋值
③在内存中加载的位置
成员变量（属性）：加载到堆（Heap)空间（非static）
局部变量：加载到栈（Static)空间

类的结构之二：方法

类中方法的声明和使用
方法：描述类应该具有的功能；
例如：Math类 sqrt()\random()……
Scanner类 nextInt(),nextDouble()……
Array类 sort(),binarySearch(),toString()……

一. 方法的声明

① 权限修饰符 返回值类型 方法名（形参列表）{
方法体 ； }
②返回值类型：
有返回值：必须在声明时，指定返回值的类型，同时使用return关键字返回指定类型的数据；
无返回值：方法声明时，用void 来声明，表示不使用return；若使用return，则写成"return；"表示结束此方法。
③方法名：属于标识符，遵循标识符的命名规则和规范 （见名知意）
④形参列表，方法可声明0个1个等多个形参
格式：方法名（数据类型1 形参1，数据类型2 形参2……）
⑤方法体 ：方法功能的体现
return 关键字的使用
① 使用范围：使用在方法体中
②作用：（1）结束此方法
（2）有返回值类型的方法，return 指定数据类型的数据；
注：return 之后，不可声明执行语句

二.方法的使用

说明：1.可以调用当前类的属性和方法
2.方法中不可以再定义方法

1.方法的重载

概念：在同一类中，允许存在一个以上的同名方法且参数列表不同；
特点：
①与返回值类型无关，只看参数列表且参数列表必须不同
如何调用： 根据参数列表的不同来调用
两同一不同：同一个类，相同方法名，参数列表不同（个数，类型）
②与此方法的权限修饰符，返回值类型，形参变量名都无关（严格按照定义）
方法重载代码示例

public int boy(int age) {
		return age=18;
	}
	public String boy(String name) {
		return name="Tony";
	}
	public void boy(String name,String sex) {
		name="Tom";
		sex="man";
	}

2.可变个数的形参

①格式：数据类型 … 变量名
Java SE 5.0中，提供了允许直接定义能和多个实参相匹配的形参，传递个数可变的实参

public void show(String ...strs){   }

②当调用可变个数形参的方法时，传入的参数个数可以是0个 1个2个……
③可重载
④可变个数形参在方法形参中，必须声明在末尾；

public void man(int m,int ...sd)//在形参列表末尾
//错误表示
public void man(int ...sd，int m)

⑤可变个数形参等同于

public void show(String[]  strs) {   }

⑥可变个数形参的使用

public class Csdn {
	public static void main(String[] args) {
		Csdn test=new Csdn();
		test.show(new String[]{"Tom","tony","Mary"});
		System.out.println();
		test.show("aa","bb","cc","dd");
	}
	public void show(String...str) {
		for(int i=0;i<str.length;i++) {
		System.out.print(str[i]+"\t");
		}
	}
		//与上述方法相同
//	public void show(String[] str) {
//		for(int i=0;i<str.length;i++) {
//		System.out.print(str[i]+"\t");
//		}
//
//}
}

3.方法参数的值传递机制

①变量的赋值
变量为基本数据类型，赋值的是变量所保存的数据值；
变量为引用数据类型，赋值的是变量所存在的地址值；其中包含变量的数据类型；
②方法形参的传递机制：值传递
1.①形参：方法声明时，小括号里的参数
②实参：调用方法时，实际传递给形参的数据
2.值传递机制
参数为基本数据类型，此时实参赋给形参的是实参真实存在的数据值；
参数为引用数据类型，此时实参赋给形参的是实参存储数据的地址值；

public class Zhi {
	public static void main(String[] args) {
		Zhi s=new Zhi();
		Swap d=new Swap();
		 d.m=19;
		d.n=80;
		System.out.println(d.m+"\t"+d.n);
		s.swap(d.m, d.n);
		System.out.println("m:"+d.m+"  "+"n:"+d.n);
		s.swap(d);
		System.out.println("m="+ d.m +"  "+"n="+d.n);
	}
	public void swap(int i,int j) {//基本数据类型的形参
		int temp=i;
		i=j;
		j=temp;
	}
	public void swap(Swap swap) {//引用数据类型的形参参
		int temp=swap.m;
		swap.m=swap.n ;
		swap.n=temp;		
	}	
}
class Swap{
	int m;
	int n;
}

在调用含基本数据类型形参的方法时，只是将实参传给了形参，并且只是进行了数据交换这一动作，并没有将交换后的数据返回给实参，所以调用时原来的实参数并没有发生交换；
在调用含引用数据类型形参的方法时，方法内交换数值，实参传给形参的是一个地址值，（实参与形参）他们所指向的是同一个地址，所以在方法体内交换的数值，在调用时，值就发生了交换；

4.递归方法（recursion）

含义：一个方法内调用它本身；
特点：包含了一种隐式的循环，会重复执行某段代码，但这种重复执行无需循环控制；
使用：这种循环一定是有方向的；否则会造成无穷递归，类似死循环；
代码示例

	//递归求阶乘
	public int   method(int num) {
		if(num==1) {
			return 1;
		}else {
			return num*method(num-1);
		}	
	}

斐波那契数列

	public int som(int num) {
		if(num<=2) {
		return 1;
		}else {
			return som(num-1)+som(num-2);
		}
	}
}

类的结构之三 构造器（构造方法）constructor

1.作用：
① 创建对象 ; 格式 new + 构造器
②初始化对象的属性
2.说明:
① 当我们没有显式的定义类的构造器，系统会默认提供一个空参的构造器
② 格式：权限修饰符+类名() { }
③ 可与其他形参列表不同的构造器构成重载
④构造器默认权限与当前类的权限相同
⑤一旦定义了显示的构造器，系统就不再提供默认的空参构造器
⑥ 一个类中至少有一个构造器

拓展 1.属性赋值顺序

属性赋值的基本操作：
① 默认初始化
②显示初始化// ③代码块中赋值
④构造器初始化
⑤对象.属性，或对象 . 方法
执行的先后顺序为 ①—>②/③—>④—>⑤

2.Java Bean

含义：是一种Java语言写成的可重用组件
符合如下标准的Java类就是一个java Bean
① 类是公共的；
②有一个无参的构造器
③有属性，且有对应的get /set 方法

类的结构之四 代码块（或初始化块）

格式：

public class Daimak {
	static String name;
	int age;
	static {
		name="大黄";
	}
	{
		age=18;
		name="Tony";
	}
}

1.作用：用来初始化类对象
2.代码块如果要被修饰的话，只能用static 修饰；
3.分类：静态代码块 VS 非静态代码块
静态代码块
①内部可以输出语句
②随着类的加载而执行，而且只执行一次；
③作用：初始化类的属性
④若一个类中定义了多个静态代码块，则按照声明的先后顺序执行；
⑤优先于非静态代码块的执行；
⑥静态代码块内只能调用静态的结构和属性，不能调用非静态的结构和属性
非静态代码块
①内部可以输出语句
②随着对象的创建而执行；
③没创建一个对象，就执行一次非静态代码块；
④非静态代码块可以调用静态和非静态代码块的结构；

类的结构之五 内部类

1.含义：Java中允许将一个类声明在另一个类B中，则类A就是内部类，类B就是外部类；
2.内部类的分类
成员内部类：静态成员内部类，非静态成员内部类
一方面：作为一个类
①类内可以定义属性和方法
②可以被final修饰表示此类不能被继承，意味着不不用final修饰可以被继承；
③可以被abstract修饰
另一方面：作为外部类的成员
①可以调用外部类的结构，属性
②可以被static修饰
③可以被四种权限修饰符修饰
注：
①如何实例化成员内部类的对象
静态成员内部类

Person.Leg o=new Person.Leg();

非静态成员内部类

Person p=new Person();
Person.Hands h= p.new Hands();

②如何在成员内部类中区分调用外部类的结构

public  class Person {
	String name="二狗";
     class Hands{
    	String name="狗子";
	 public void playget(String name) {
		 System.out.println(name);//方法形参
		 System.out.println(this.name);//内部类属性
		 System.out.println(Person.this.name);//外部类属性	 
	 }		
	}
	}

③开发中如何使用
返回一个实现了某接口（如Comparable接口）的类的对象；
3.成员内部类和局部内部类在编译后都会生成字节码文件
格式：成员内部类 Person$Hands.class
局部内部类：Person$1AA.class

局部内部类使用当中的一个注意点：
在局部内部类的方法中，如果调用局部内部类所声明的方法中的局部变量，要求此局部变量声明为final的（jdk 7及以前）
jdk 8 之后 可以省略 final的声明

class Animal{
	public void show() {
	 int num=10;
		class Dog{
			public void sow() {
//				num=20;不能修改只能调用
				System.out.println(num);
			}
		}
	}
}