java入门之面向对象

1、面向对象的概念

（1）java语言是一种纯面向对象的语言。

（2）历史：

C语言是一种面向过程的语言。
C++语言是一种既面向过程，又面向对象的语言。
Java来源于C++，是一种纯面向对象的语言。

（3）面向过程和面向对象的区别

他们都是解决问题的思想。
面向过程：通过过程来解决问题，没有对象的概念，只是如何解决这个问题的过程。
面向对象：通过对象来解决问题，需要先构建对象（赋予解决问题的能力），然后指挥对象去解决问题。

（4）对象

万事万物皆为对象。
对象是一个具体存在的能够解决问题的个体。

如何区别：通过对象的属性和行为。

属性是记录对象的特征的。
行为是对象解决问题的能力。

（5）类

类是创建对象的模板，有类才有对象。

在类里面定义对象应该有的属性和行为。

（6）面向对象

倒退：
遇到问题–>通过对象解决问题–>对象–>类

写程序：
遇到问题，分析问题；
通过分析，抽象成类；
通过类，创建对象；
通过对象，解决问题。

2、面向对象实战思路

（1）问题：小王是一个死胖子，通过努力，减肥成功（由200公斤到148斤）。

（2）类：

人类{
姓名，体重；
减肥；
}

（3）创建对象

小王=New 人类

（4）减肥

小王.减肥

3、面向对象实战编码

（1）类的定义

[修饰符public] class 类名{
1>属性
[修饰符public] 数据类型 属性名[=初始值];
2>方法
[修饰符public static] 返回值类型void 方法名([参数]){
//方法体：解决问题的过程
}
}
案例：

---

public class Person {
public  String  name;
public  double  weight;
public  void   loseWeight() {
	System.out.println("减肥成功!");
}
}

---

（2）创建对象

类名 对象名=new 类名();
案例：
public static void main(String[] args) {
Person p=new Person();
}

（3）使用对象

对象名.属性名
对象名.方法名()
案例：
p.name=“小王”;
p.weight=200;
p.loseWeight();

4、创建对象的过程

调用：
p.name p里面保存了对象在堆里的地址，通过这个地址找这个对象的存储空间，然后找到里面的name属性。
p.loseWeight() p里面保存了对象在堆里的地址，通过这个地址找这个对象的存储空间，然后找到loseWeight()方法，执行方法体。

5、OOP案例（长方形）

---

public class Rect {
	public  double  length;
	public  double  width;
	public  void  girth() {
		System.out.println("长方形的周长："+(length+width)*2);
	}	
	public  void  area() {
		System.out.println("长方形的面积："+length*width);
	}
	public static void main(String[] args) {
		Rect   r1=new  Rect();
		r1.length=2;
		r1.width=3;
		r1.girth();
		r1.area();	
		Rect   r2=new  Rect();
		r2.length=5;
		r2.width=5;
		r2.girth();
		r2.area();
	}
}

---

6、构造器的定义

（1）创建对象

new 类名();
这里调用的其实是构造器！！

（2）构造器

构造对象的过程。

定义：
【修饰符】 构造器名字([参数]){
方法体
}
注意：构造器名字必须使用类名！！！！

案例：
构造器：构造方法
public Circle() {
构造对象之后，用于初始化这个对象的属性操作
r=4;
}

（3）使用构造器

new 构造器名();
执行过程：
首先，通过类构造一个对象；
然后，执行方法体完成该对象的属性初始化。

（4）缺省构造器

如果类中没有定义构造器，系统会在编译时提供一个缺省的无参构造器。
缺省构造器：public 类名(){}

但是，如果你定义了构造器，系统就不会提供缺省构造器了。

案例：

---

package day04;
public class Circle {
	public  double  r;
	public  double  PI=3.14;	
	public  void  grith() {
		System.out.println(PI*r*2);
	}
	public  void  area() {
		System.out.println(PI*r*r);
	}
	//构造器：构造方法
	public  Circle() {
		//构造对象之后，用于初始化这个对象的属性操作
		r=4;
	}
}

---

7、变量

（1）变量

分为两种：成员变量和局部变量。

成员变量：定义在类中，对象的属性。
局部变量：定义在方法体中的变量。

（2）成员变量与局部变量的区别

第一，声明位置不同：成员变量是定义在类中方法体外，局部变量定义在方法体内。
第二，修饰符不同：成员变量前可以使用各种修饰符修饰，局部变量只能使用final。
第三，作用范围（作用域）不同：成员变量可以作用所有方法体，局部变量只能作用于当前方法体。
第四，缺省值不同：成员变量有缺省值，局部变量没有缺省值。

（3）成员变量缺省值

整数类型，0
浮点类型，0.0
char类型，空白字符
布尔类型，false
引用类型，null

（4）变量重名问题

变量的作用域：一个变量只能在声明它的最小语句组中使用，超出这个语句组就不能使用。

重名规则：
一个类中，所有的成员变量之间，不可以重名。
一个方法中，所有的局部变量之间，不可以重名。
成员变量可以和局部变量重名，方法内直接使用的是局部变量。

案例：

---

package day04;
public class Student {
	//成员变量，也叫属性
	//public final  int     no=10;
	public  int     no;
	public  String  name;
	public  char    sex;
	public  boolean isGraduate;
	public   void  test() {
		//局部变量
		final int   a;
		a=10;
		//a=11;
		int   b=11;
		System.out.println(no);
		System.out.println(name);
		System.out.println(a);
		System.out.println(b);
	}
	public   void  test2() {
		System.out.println(no);
		System.out.println(name);
	//	System.out.println(a);
	//	System.out.println(b);	
		int  a=1;
		int  b=2;
		System.out.println(a);
		System.out.println(b);
	}
	public   void  test3() {
		int  a=1;
		{
			int  b=2;
			System.out.println(a);
			System.out.println(b);
		}	
	/	System.out.println(a);
	//	System.out.println(b);
		int  no;
	//	System.out.println(no);
	}
	public Student() {
		//局部变量
		int  c;
		int  d;
		System.out.println(no);
		System.out.println(name);
	//	System.out.println(a);
	//	System.out.println(b);
		
	//	System.out.println(c);
	//	System.out.println(d);	
		System.out.println(sex);
		System.out.println(isGraduate);
	}
	public static void main(String[] args) {
		new  Student();
	}
}

---

8、成员方法-参数

1）参数

作用：将数据动态传入方法体内使用

定义：
定义在方法名或构造器后的小括号里；
参数的作用域是当前方法体；
参数类型 参数名,…

和局部变量比较：
参数和局部变量一样，只能作用于当前方法体；
局部变量的数据是固定的，而参数的数据是可以变化的。

赋值：
参数赋值，不是用等号，而是调用方法或构造器时通过小括号传入的。
调用方法或构造器时，如果定义了参数，那么需要传入数据，数据的顺序、类型、数量必须和定义时一致。

名称解释：
形参，定义方法时小括号里面的参数。
实参，调用方法时传入的数据，使用实参给形参赋值。

重名问题：参数可以成员变量重名，不可以和局部变量重名。

案例：

---

public class SumDemo {
	public  void   sum(int  a,int  b) {
		//int  a=10,b=20;
		System.out.println(a+b);
	}
	public static void main(String[] args) {
		SumDemo  sd=new SumDemo();
		sd.sum(1,2);
		sd.sum(3,4);
		sd.sum(10,20);
	}
}

（2）方法的重载

在同一类中，出现多个方法的方法名相同但是参数列表必须不同。

参数不同：
数量不同；
数量相同，但是对应顺序的参数类型至少有一个不同。
参数名在调用时，不能作为参数不同的依据。

---

public class SumDemo {
	public  void   sum() {		
		System.out.println(10+20);
	}
	public  void   sum(int  a,int  b) {	
		System.out.println(a+b);		
	}
	public  void   sum(int  a,int  b,int  c) {	
		System.out.println(a+b+c);
	}	
	public  void   sum(int  a,double  b) {		
		System.out.println("我们不一样："+a+b);
	}	
	public  void   sum(double  a,int  b) {	
		System.out.println("我们不一样："+a+b);
	}	
	public  void sum(double  c,double  d) {
		System.out.println("double 2:"+(c+d));
	}
	public static void main(String[] args) {
		SumDemo  sd=new SumDemo();
		sd.sum(1,2);
		sd.sum(3,4);
		sd.sum(10,20);		
		sd.sum();
		sd.sum(1, 2, 3);
		sd.sum(12.1, 12.2);
		sd.sum(1,2.0);
		sd.sum(2.0,1);
	}
}
***

（3）构造器的重载

在同一个类中允许定义多个构造器，但是参数必须不同，这种现象我们叫构造器重载。

主要目的：完成创建对象后的不同初始化需求。
//构造器：构造方法

---

public  Circle() {
	//构造对象之后，用于初始化这个对象的属性操作
	//r=4;
}
public  Circle(double  rr) {
	//构造对象之后，用于初始化这个对象的属性操作
	r=rr;
}
public  Circle(double  rr,double  tt) {
	//构造对象之后，用于初始化这个对象的属性操作
	r=rr;
	t=tt;
}
    Circle  c1=new  Circle();
	System.out.println(c1.r);
	System.out.println(c1.t);
	System.out.println(c1.PI);
	Circle  c2=new  Circle(3);
	System.out.println(c2.r);
	System.out.println(c2.t);
	System.out.println(c2.PI);
	Circle  c3=new  Circle(3,4);
	System.out.println(c3.r);
	System.out.println(c3.t);
	System.out.println(c3.PI);

---