JAVA：类和对象基础

编译器技巧

• Ctrl+鼠标就会自动跳转到函数位置。
• • 如果是JAVA自带的包，在jdk/jre的lib目录下的rt.jar包中，需要自己导入
• 我们定义的类会自动继承object的类
• debug时候
• 快速构建 构造方法：
• • Source->Generate super constructor to invoke
• 快速设计to String：
• • Source->Generate to String

基本概念

对象：世界万物皆对象

每个对象都会从两个角度描述:

• 静态 属性: 对象所拥有的各种特征，每个对象的属性所拥有的值.
• 动态 (行为)方法: 对象执行的操作

封装:

将属性及方法相结合,共同体现对象的特性.
对象的属性和方法通常被封装在一起

类: 对象的抽象

具有相同属性和共同行为的一组对象的集合.

对象中抽取属性和行为的共同特征,从而抽象出类
类是构造对象的模板
类是一个高度抽象的概念
类相当于一个新的数据类型

关系：类是对象的抽象，对象是类的实例

基本操作：

类的定义

举例

public class Cubic
{
	//底面长。宽
	int a;
	int b;
	int c;//高
	
	//下面是方法
	
	  //求底面周长
	public int length()
	{
		return 2*(a+b);
	}
	//求底面面积
	public int area()
	{
		return a*b;
	}
	//求长方形表面积
	public int totalArea()
	{
		int d=2*(a*b+a*c+b*c);
		return d;
	}
	//求长方体体积
	public int volumn()
	{
		int d=a*b*c;
		return d;
	}
}
 

方法嵌套其他方法

例如上面的表面积和体积，可以改成

//求长方形表面积
	public int totalArea()
	{
		//int d=2*(a*b+a*c+b*c);
	    int d=2*area()+length()*c;
		return d;
	}
	//求长方体体积
	public int volumn()
	{
		//int d=a*b*c;
		int area()*c;
		return d;
	}

用类创建对象

public class Main {
	public static void main(String[] args) {
	//创建对象
	Cubic cubic =new Cubic();
	//使用
   cubic.a=10;
	System.out.println(cubic.a);
	System.out.println(cubic.b);
		
	cubic.b=20;
	cubic.c=30;
	System.out.println(cubic.length());
	}
	}
}

创建过程：

1. 系统加载类的字节码（只加载一次）
2. new操作：

• 根据字节码，在堆内存中为该类的成员变量中的实例变量分配内存，并赋默认值；
• 第一次创建类的实例时，分配实例方法的入口地址。

3. 将对象的引用传递给变量

优点

1.面向对象程序设计可以模拟现实世界
2.类的封装性，其余人可以直接使用，不用关心具体实现
3.提高代码的重用性

垃圾回收机制

	protected void finalize() throws Throwable
	{
          System.out.println(".....finis..");
		  //回收时输出提示
	}
public static void main(String[] args) {
	Bfd abc=new Bfd();
	int x=1;
	int y=2;
	int z=3;
	Bfd abcd=new Bfd(x,y,z);
	System.out.println(abc);
	System.out.println("abcd: "+abcd.a);
	System.out.println(abc.totolArea());
	abc=null;//垃圾回收机制
	System.gc();//垃圾回收机制

成员变量与局部变量

成员变量分类

实例变量和类变量

区别

• 作用域不同
• • 成员变量：是类的属性，在类内都有效。（在类内位置随意，即使在语句下方定义也可以）
• • 局部变量：方法行参，复合语句内部，循环语句内部，判断语句内有效
• 初始值不同
• • 成员变量：初始值为0，局部变量：没有初始值

重名时引用问题

如果成员变量与局部变量重名（例为a）
局部变量的优先级高
直接使用 a 默认是使用局部变量
如果想使用成员变量，使用this.a

构造方法

作用：
(1）创建新的实例（对象）
(2)初始化实例(对象）中的实例变量
特点：
(1）与类同名
(2）没有返回值（void不能写）
(3）必须有（如果不创建，系统自动创建）

提示：一旦在类中定义了构造方法，系统就不会再创建这个默认的不含参数的构造方法。

• 可以含有多个构造方法（重载）
• 定义时，必须具有不同的参数列表
• 程序运行时，根据分配对象时所指定的参数数据类型、参数个数，决定使用哪一个构造函数创建对象。

public class Sqyare {
 
	 int a;
	  
	 public Sqyare()
	 {
		 a=1;
	 }
	 public Sqyare(int a)
	 {
		 this.a=a;
	 }
	 public  int area()
	 {
		 return a*a;
	 }
	 public static void main (String[] args)
	 {
		 Sqyare s1 = new Sqyare();
		 Sqyare s2=new Sqyare(10);
		 System.out.println(s1.area());
		 System.out.println(s2.area());
	 }
	 
}
 

成员方法

基本操作

定义格式
[访问权限修饰词] 返回类型 方法名（参数列表）
{
方法体
}

返回值
最多有一个，但不限于基本数据类型

不定长参数列表定义

例：public int sum（int b，int... a）
要求：

1. 不定长参数必须是最后一个参数
2. JAVA是按数组处理的不定长参数 int ...a--->int[] a

值传递和引用传递

值传递：

• 形参改变实参不改变，基本数据类型变量使用值传递

引用传递：

• 两个参数共享地址，引用型数据类型使用引用传递

方法的重载

特点：
方法名称相同，参数个数或者数据类型不同。 返回值类型可以相同
例如：

	public int a(int b)
	{
		return b;
	}
	public int a(char b)
	{
		return b;
	}
	public int a(int a,int b)
	{
		return a;
	}

类方法和实例方法

类方法：

返回类型前加：static
使用限制：

• 只能调用类方法和类变量
• 不能直接调用实例方法和实例变量

实例方法：

无static
不受限制的使用
案例：

public class Sqyare {
 
	static int aaa=10;
		 int a;
	public static void m3()
	{
	  System.out.println(aaa);
	  System.out.println(a);//报错
	  m1(10);//报错
	}
	
	public void m1(int mmm)
	{
		mmm=100;
		System.out.println(mmm);
		  System.out.println(a);
	}
 

返回多个变量

注解1：toString函数

如果类里面有toString方法，输出时候可以不用写.toString,系统输出时候可以自动调用。

方法1：在函数里面直接输出

public class Point {
  int x;
  int y;
public Point(int x, int y) {
	super();
	this.x = x;
	this.y = y;
}
public void move(int dx,int dy)
{
	//设目前 对象为a
	x=x+dx;
	//对象a的x值加上dx
	y=y+dy;
	//对象a的y值加上dy
}
 
@Override
public String toString() {
	return "Point [x=" + x + ", y=" + y + "]";
}
public static void main(String[] args) {
	Point aa=new Point(1,2);
	aa.move(1, 2);
	System.out.println(aa);
	aa.move(2, 2);
	System.out.println(aa);
}
}

方法2:返回对象

public class Point {
  int x;
  int y;
public Point(int x, int y) {
	super();
	this.x = x;
	this.y = y;
}
public Point move(int dx,int dy)
{
	//设目前 对象为a
	x=x+dx;
	//对象a的x值加上dx
	y=y+dy;
	//对象a的y值加上dy
	return new Point(x,y);
	//返回一个用对象a的（x，y）创建的 新Point
	//新Point包含a的（x，y），则输出新Point==输出对象a
}
 
@Override
public String toString() {
	return "Point [x=" + x + ", y=" + y + "]";
}
public static void main(String[] args) {
	Point aa=new Point(1,2);
	
	System.out.println(aa.move(1, 2));
	
	System.out.println(aa.move(2, 2));
}
}

枚举类

创建：

public enum WeekDay {
	SUN,MON,TUE,WED,THU,FRI,SAT;//7个对象
}

使用：

  WeekDay day=WeekDay.SUN;//输出结果为Sun
	 System.out.println(day);
	 WeekDay[] days= WeekDay.values();
	 for(WeekDay day1:days)
	 {
		 System.out.println(day1);
	 }

高级创建：

/*
*输出结果是1,2,3,4,5,6，7
*/
public enum WeekDay {
SUN2(1),MON2(2),TUE2(3),
WED2(4),THU2(5),FRI2(6),SAT2(7);
	//本质是7个对象
	int value;
	private WeekDay(int value)
	{
		this.value=value;
	}
	private WeekDay()
	{
	}
	@Override
	public String toString() 
	{
		return this.value+"";//数字连接空白字符串->自动变成数字字符串
	}
}

人工模拟：