Java基础篇---面向对象（上）

Java基础篇---面向对象（上） 1、面向对象

概念：略

1.1、学习面向对象的三条主线

1、Java类及类的成员：属性，方法，构造器，代码块，内部类
2、面向对象的三大特征：封装，继承，多态
3、其它关键字：this、super、static、final、abstract、interface、package、import 等

1.2、面向对象的2个要素

类和对象

2、类和对象

类:对一类事物的描述，是抽象的、概念上的定义对象:是实际存在的该类事物的每个个体，因而也称为实例(instance)。 1、类

面向对象程序设计的重点是类的设计；
设计类，其实就是设计类的成员。

1.1、类的语法格式

2、对象 2.1、对象的创建和使用

创建对象语法： 类名 对象名 = new 类名();
使用“对象名.对象成员”的方式访问对象成员（包括属性和方法）

3、面向思想的落地实现

创建类 = 类的实例化 = 实例化类
二.类和对象的使用(面向对象思想落地的实现)1.创建类，设计类的成员

Field = 属性 = 成员变量 = 域、字段Method = (成员)方法 = 函数 2.创建类的对象3.通过“对象.属性”或“对象.方法”调用对象的结构 4、特性

1、如果创建类一个类的多个对象，则每个对象都独立的拥有一套类的属性。(非 static 的)
意味着:如果我们修改一个对象的属性 a，则不影响另外一个对象属性 a 的值。
2、类的访问机制：
在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。（例外：static方法访问非static，编译不通过。）
在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中
定义的成员。

例子

//测试类
public class PersonTest {
	public static void main(String[] args) {
		//2.创建 Person 类的对象
		//创建对象语法：类名对象名= new 类名();
		Person p1 = new Person();
		//Scanner scan = new Scanner(System.in);
		
		//调用类的结构：属性、方法
		//调用属性:“对象.属性”
		p1.name = "Tom";
		p1.age = 25;
		p1.isMale = true;
		System.out.println(p1.name);
		
		//调用方法:“对象.方法”
		p1.eat();
		p1.sleep();
		p1.talk("chinese");
		/
//1.创建类，设计类的成员
class Person{
	
	//属性:对应类中的成员变量
	String name;
	int age;
	boolean isMale;
	
	//方法:对应类中的成员方法
	public void eat(){
		System.out.println("吃饭");
	}
	
	public void sleep(){
		System.out.println("睡觉");
	}
	
	public void talk(String language){
		System.out.println("人可以说话，使用的是：" + language);
	}
}

5、匿名对象

我们也可以不定义对象的句柄，而直接调用这个对象的方法。这
样的对象叫做匿名对象。
如：new Person().shout();
使用情况
如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。
我们经常将匿名对象作为实参传递给一个方法调用。

3、类的成员之一：属性 1、语法格式

修饰符 数据类型 属性名 = 初始化值 ;
说明1: 修饰符

常用的权限修饰符有：private、缺省、protected、public其他修饰符：static、final (暂不考虑)
说明2：数据类型
任何基本数据类型(如int、Boolean) 或 任何引用数据类型。
说明3：属性名
属于标识符，符合命名规则和规范即可。 2、成员变量和局部变量

在方法体外，类体内声明的变量称为成员变量。
在方法体内部声明的变量称为局部变量。
注意：局部变量除形参外，都需要显示赋值后才能使用。

3、区别

4、成员变量默认初始值

5、例子及练习

public class UserTest {
	public static void main(String[] args) {
		User u1 = new User();
		System.out.println(u1.name);
		System.out.println(u1.age);
		System.out.println(u1.isMale);
		
		u1.talk("俄语");
	}
}
class User{
	//属性(或成员变量)
	String name;	//不加权限修饰符，即为缺省
	public int age;	//加了public，即可被任意访问
	boolean isMale;
	
	public void talk(String language){//language:形参，也是局部变量，在该方法调用时赋值
		System.out.println("我们使用" + language + "进行交流。");
	}
	
	public void eat(){
		String food = "石头饼";	//石头饼:局部变量
		System.out.println("北方人喜欢吃:" + food);
	}
}

public class School {
	public static void main(String[] args) {
		Student stu = new Student();
        stu.name = "小明";
        stu.age = 16;
		
		Teacher tea = new Teacher();
		tea.name = "王老师";
        tea.age = 27;
        
        tea.say(stu.name,stu.age);
        stu.say(tea.name, tea.age);
	}	
}
class Student{
	String name;
	int age;
	String major;
	String interests;
	
	void say(String name, int age){
		System.out.println("这个学生是："+name+"年龄是："+age);	}
}
class Teacher{
	String name;
	int age;
	String teachAge;
	String course;
	
	void say(String name, int age){
		System.out.println("这个老师是："+name+"年龄是："+age);
	}
}

4、类的成员之二：方法 1、方法的声明格式

权限修饰符：默认方法的权限修饰符先都使用public
Java规定的4种权限修饰符：private、public、缺省、protected
返回值类型： 有返回值 vs 没有返回值
如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字来返回指定类型的变量或常量：“return 数据”。
如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。

2、例子

1、return关键字的使用：
使用范围:使用在方法体中
注意点:return关键字后不可声明执行语句。
2、方法的使用中，可以调用当前类的属性或方法。
特殊的:方法A中又调用了方法A:递归方法。
方法中不能定义其他方法。

public class CustomerTest {
	public static void main(String[] args) {
		
		Customer cust1 = new Customer();
		
		cust1.eat();
		
		//测试形参是否需要设置的问题
//		int[] arr = new int[]{3,4,5,2,5};
//		cust1.sort();
		
		cust1.sleep(8);
		
	}
}
//客户类
class Customer{
	
	//属性
	String name;
	int age;
	boolean isMale;
	
	//方法
	public void eat(){
		System.out.println("客户吃饭");
		return;
		//return后不可以声明表达式
//		System.out.println("hello");
	}
	
	public void sleep(int hour){
		System.out.println("休息了" + hour + "个小时");
		
		eat();
//		sleep(10);
	}
	
	public String getName(){
		
		if(age > 18){
			return name;
			
		}else{
			return "Tom";
		}
	}
	
	public String getNation(String nation){
		String info = "我的国籍是：" + nation;
		return info;
	}
	
	//体会形参是否需要设置的问题
//	public void sort(int[] arr){
//		
//	}
//	public void sort(){
//		int[] arr = new int[]{3,4,5,2,5,63,2,5};
//		//。。。。
//	}
	
	public void info(){
		//错误的
//		public void swim(){
//			
//		}
		
	}
}

5、再谈方法 1、方法的重载

概念：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
重载的特点：
与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

2、可变个数的形参

JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。

说明

1、声明格式：方法名(参数的类型名 …参数名)
2、当调用可变个数形参的方法时，传入的参数的个数可以是：0个，1个，2个…
3、可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。即二者不可共存。
4、可变个数形参在方法中的形参中,必须声明在末尾。
5、可变个数形参在方法中的形参中，最多只能声明一个可变形参。

public class MethodArgs {

	public static void main(String[] args) {
		MethodArgs test = new MethodArgs();
		test.show(12);
		// test.show("hell0");
		// test.show("hello","world");
		// test.show();

		test.show(new String[] { "AA", "BB", "CC" });
	}

	public void show(int i) {

	}

	// public void show(String s){
	// System.out.println("show(String)");
	// }
	public void show(String... strs) {
		System.out.println("show(String ...strs)");


		for (int i = 0; i < strs.length; i++) {
			System.out.println(strs[i]);
		}
	}

	// 此方法与上一方法不可共存
	// public void show(String[] strs){
	//
	// }

	public void show(int i, String... strs) {

	}

	//The variable argument type String of the method show must be the last parameter
//	public void show(String... strs,int i,) {
//
//	}
}

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

public class ArrayPrint {

	public static void main(String[] args) {
		int[] arr = new int[]{1,2,3};
        //传进去的是一个Object的对象
		System.out.println(arr);//地址值
		
		char[] arr1 = new char[]{'a','b','c'};
        //传进去的是一个数组，里面遍历数据了
		System.out.println(arr1);//abc
	}
}

原因：

面向对象特征之一：封装与隐藏

问题的引入：
当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值 *** 作要受到属性的数据类型和存储范围的制约。但除此之外，没有其他制约条件。但是，实际问题中，我们往往需要给属性赋值加入额外限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行条件的添加。比如说，setLegs同时，我们需要避免用户再使用“对象.属性”的方式对属性进行赋值。则需要将属性声明为私有的(private) --》此时，针对于属性就体现了封装性。

四种权限修饰符的理解与测试

Java 权限修饰符public、protected、default(缺省)、private 置于类的成员定义前，用来限定对象对该类成员的访问权限。

对于 class 的权限修饰只可以用 public 和 default(缺省)。

public 类可以在任意地方被访问。
default 类只可以被同一个包内部的类访问。

7、构造器 1、构造器的理解和使用

语法格式
构造器的特征

它具有与类相同的名称它不声明返回值类型。（与声明为void不同）不能被static、final、synchronized、abstract、native修饰，不能有
return语句返回值（只能使用权限修饰符）

特别说明：

1.如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器，默认构造器的修饰符和所属类的修饰符一致。2.一个类中定义的多个构造器，彼此构成重载。3.一旦显示的定义了类的构造器之后，系统不再提供默认的空参构造器。4.一个类中，至少会有一个构造器5.父类的构造器不可被子类继承
构造器的作用:1.创建对象2.初始化对象的属性 2、总结属性赋值的过程

① 默认初始化值② 显式初始化③ 构造器中赋值④ 通过"对象.方法" 或 “对象.属性”的方式，赋值 3、JavaBean 的使用

JavaBean 是一种 Java 语言写成的可重用组件。所谓 javaBean，是指符合如下标准的 Java 类：
> 类是公共的
> 有一个无参的公共的构造器
> 有属性，且有对应的 get、set 方法 8、关键字：this 的使用

this代表的意义：
它在方法内部使用，即这个方法所属对象的引用；
它在构造器内部使用，表示该构造器正在初始化的对象。
总之，this 理解为：当前对象,或当前正在创建的对象。

this使用场景

用this来区分属性和局部变量使用this，调用属性、方法

在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性和方法。通常情况下，我们都选择省略“this.”。特殊情况下，如果方法的形参和类的属性同名，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用正在创建的对象属性和方法。但是，通常情况下，我们都选择省略“this.”。特殊情况下，如果构造器的形参和类的属性同名，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。 使用this调用本类的构造器

① 我们可以在类的构造器中，显式的使用"this(形参列表)"的方式，调用本类中重载的其他的构造器！② 构造器中不能通过"this(形参列表)"的方式调用自己。③ 如果一个类中声明了n个构造器，则最多有n -1个构造器中使用了"this(形参列表)"。④ "this(形参列表)"必须声明在类的构造器的首行！⑤ 在类的一个构造器中，最多只能声明一个"this(形参列表)"。 9、import和package关键字

略