Java学习（二）面向对象基础

一、面向对象思想

1.编程语言的发展

2.什么是类？什么是对象？

类
用于描述同一类型事物的一个抽象的概念。
类中定义了这一类对象具有的静态和动态属性。
类也称为模板，提供了对象的基本框架。

对象
对象表示现实世界中某个具体的事物。
对象具有两方面的含义：
①在现实世界中：是客观世界中的一个实体。
②在计算机世界中：是一个可标识的存储区域。

3.面向对象特征

封装性：Java中，所有代码都封装在类内；
继承性：子类自动继承父类的属性和方法，继承性是面向对象程序设计语言不同于其他语言的最重要的特点；(重点)
多态性：相同的操作、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，即具有不同的表现行为，这种现象称为多态性。

二、类与对象

1.类的声明

类（class）定义了一种新的数据类型，是具有相同特征（属性）和共同行为（方法）的一组对象的集合。

（1）定义类的语法格式为：
[访问符][修饰符] class 类名
{
   [属性]
   [方法]
}
属性定义的一般格式为：
type variableName=[initValue];

（2）属性在定义时，需要初始化。（成员变量：有默认初始化值，局部变量：必须手动赋初值。）
示例：
public int i=10;
private float f=1.0;
private boolean b=false;

（3）方法定义的一般格式为：
type methodName(param-list)
{
// 方法体
}
示例：
public int getMax(int a,int b)
{
return (a>b?a:b);
}

访问符：用于指明类、属性或方法的访问权限，可以是public、protected、private或默认；
修饰符：用于指明所定义的类的特性，可以是abstract、static或final等；
类名：指所定义类的名字，类名的命名必须符合命名规范，Java中类名通常由一个或多个有意义的单词连缀组成，每个单词的首字母大写，其他字母小写，如，PersonBase等。

2.系统类库

类库是已经实现了的标准的类的集合，用于完成基本的或者底层的功能，可以帮助开发者便捷的开发java程序。
java中的类根据功能的不同分为多个包，常用的包主要包括：
java.lang   语言核心包，自动导入。
java.awt   图形用户界面。
javax.swing   图形用户界面。
java.io   标准输入、输出类库。
java.util   工具包。
java.net   网络功能。

3.访问控制

访问控制符用于类、属性、函数的定义中以规定其访问权限。
访问控制符规定的权限分为四种，权限从小到大分别为：
–private 私有的，只有本类可以访问
–默认 没有控制符时是默认访问权限，包内的类可以访问
–protected 受保护的，不同包的子类可以访问
–public 公开的，任何类都可以访问
只有public和默认访问权限可以修饰类。

4.对象的创建和使用

创建对象的语法为：
className variableName=new className(param-list);
创建对象的过程：
（1）使用new在堆里开辟空间，然后清零；
（2）显示初始化，按照定义顺序为变量赋初值；
（3）调用构造函数。
Java中对象的存储方式：占两块内存
堆里的对象
栈里的引用

public class Test1{
  int x=1;
  int y=f();
  int z=5;
  int f(){
    System.out.println("x="+x+",y="+y+",z="+z);//1,0,0
    return z;
  }
  Test1(int a, int b, int c){
    System.out.println ("x="+x+",y="+y+",z="+z);//1,0,5
    x=a;
    y=b; 
    z=c;
  }
  public static void main(String[] args){
    Test1 t= new Test1(10,10,10);
    System.out.println ("x="+t.x+",y="+t.y+",z="+t.z);//10,10,10
  }
}

三、方法

1.构造函数

构造函数有以下特点：

1. 名字特殊：函数名与类名相同。
2. 格式特殊：没有返回值。
3. 用途特殊：主要用于完成对象的初始化操作。
4. 调用特殊：不能显示调用，由系统在创建对象时自动调用。

如果在类中没有定义任何的构造方法，则编译器将会自动加上一个不带任何参数的构造方法，即默认构造方法，该方法不存在于源程序中，但可以使用。例如Person类中不提供任何构造方法时，默认下面构造方法：public Person(){}
一旦类创建了自己的构造方法，默认的构造方法将不复存在，如果还想使用，可以显示的写出来。

2.函数的重载

重载指在一个类当中，具有同一个名字但参数不同（参数个数或类型不同）的多个函数。
编译器根据重载函数的参数来决定调用的函数，因此，重载函数的参数表一定不同，即参数的数量或类型不同。
构造函数也是函数的一种，因此构造函数也可以进行重载。

public class Person{
	int id;
	int age=20;
	Person(){
	  id = 1;
	  age = 20;
	}
	Person(int _id){
	  id = _id;
	  age=25;
	}
	Person(int _id,int _age){
	  id = _id;
	  age = _age;
	}
public void info(){
	  System.out.println("my id is "+id);	
	}
	public void info(String p){
	  System.out.println(p+" id is "+id);
	}
	public static void main(String[] args) 
	{
		Person tom=new Person();
		Person lily=new Person(2);
		Person jerry=new Person(3,28);//调用对应构造函数
		tom.info();
		lily.info("beauty");
	}
}

函数重载不能以返回值类型的不同来进行区分。
示例：
bool f();
int f();
x=f(); //此时可根据x类型决定调用哪一个函数
f(); //此时将不能够区分。

3.可变参数

格式：只需在方法的最后一个参数的数据类型后增加3个点（…）即可。
如：public int add(int a,int…b){//…省略}
上例中b是一个可变参数，该参数可接受多个参数值，多个参数值被当做数组传入。

使用可变参数时的注意事项：
a.可变参数只能处于参数列表的最后；
b.一个方法中最多只能包含一个可变参数；
c.可变参数的本质就是一个数组，因此在调用时，既可以传入多个参数，也可以传入一个数组。

import java.io.*;
public class ChangeParamDemo{
	public static int add(int a,int...b){
		int sum=a;
		for(int e:b){
			sum+=e;
		}
		return sum;
	}
	public static void main(String[] args){
		System.out.println ("3+4 = "+add(3,4));
		System.out.println ("3+4+5 = "+add(3,4,5));
		System.out.println ("3+4+5+6 = "+add(3,4,5,6));
		int[] nums = {7,8,9,10,11,12};
		System.out.println ("sum = " + add(6,nums));
  }
}

4.参数传递

方法可以带参数，通过参数可以给方法传递数据。根据参数的使用场合，可以将参数分为“形参”和“实参”两种。
形参：声明方法时给方法定义的形式上的参数，此时形参没有具体的数值，形参前面必须有数据类型，使用格式是“方法名(形参)”；
实参：调用方法时程序给方法传递的实际数据，实参前面没有数据类型，使用格式是“对象名.方法名(实参)”。
实参和形参之间传递数值的方式有两种：
值传递（call by value）：参数的类型是基本数据类型时
引用传递（call by reference）：参数类型是引用类型时

（1）值传递

值传递是将实参的“值”传递给形参，被调方法为形参创建一份新的内存拷贝来存储实参传递过来的值，然后再对形参进行数值操作。
值传递时，实参和形参在内存中占不同的空间，当实参的值传递给形参时，两者之间将互不影响，因此形参值的改变不会影响原来实参的值。

import java.io.*;
public class ValueTransferDemo{
	public static void swap(int a,int b){
		int tmp=a;
		a=b;
		b=tmp;
		System.out.println (“swap方法里，a= ”+a+”;b=”+b);
	}
	public static void main(String[] args){
		int a=6;
		int b=9;
		System.out.println (“swap方法里，a= ”+a+”;b=”+b);
		swap(a,b);
		System.out.println (“swap方法里，a= ”+a+”;b=”+b);
  }
}

（2）引用传递

引用传递是将实参的“地址”传递给形参，被调方法通过传递的地址获取其指向的内存空间，从而在原来的内存空间直接进行操作。
引用传递时，实参和形参指向内存中的同一空间，因此当修改了形参的值时，实参的值也会改变。

import java.io.*;
class Mydata{
		public int a;
		public int b;
	}
public class RefernceTransferDemo{
		public static void swap(Mydata data){
		int tmp=data.a;
		data.a=data.b;
		data.b=tmp;
		System.out.println (“swap方法里，a= ”+data.a+”;b=”+data.b);
	}
	public static void main(String[] args){
		Mydata data=new Mydata();
		data.a=6;
		data.b=9;
		System.out.println (“swap方法里，a= ”+data.a+”;b=”+data.b);
		swap(data);
		System.out.println (“swap方法里，a= ”+data.a+”;b=”+data.b);
  }
}

四、包

1.包的概念

计算机操作系统使用文件夹或者目录来存放相关或者同类的文档，在Java编程语言中，提供了一个包的概念来组织相关的类。包在物理上就是一个文件夹，逻辑上代表一个分类概念。
Java中的基础类库就是使用包进行管理的。

2.包的声明

（1）创建包的语句是使用关键字package，而且应该是整个java文件的第一个语句。
（2）包内的类名唯一，一般使用域名的倒写。如：package com.edu.ysu；

3.包的编译运行

package com.edu.ysu;
public class PackageDemo {
        public static void main(String[] args) {
                System.out.println(“packageDemo");
	}
}

编译：javac -d . PackageDemo.java（编译后会自动产生文件目录.\com\edu\ysu，如果使用正常的编译命令，则需要手工把字节码.class文件放到.\com\edu\ysu目录下。）
运行：java com.edu.ysu.PackageDemo

4.包的导入

引用包中的类时，使用import语句。import语句的基本格式为import 包名.类名，其中import为关键字，包名和类名之间用圆点(.)隔开。
如导入上例中的类：
import com.edu.ysu.*；
注：这里 “ * ” 只代表com. edu.ysu包下的class文件，不包括下层包中的class文件。

五、4个关键字

1.static关键字

static可以修饰变量、方法和代码段。
修饰变量——静态变量
修饰方法——静态方法
修饰代码段——静态块

（1）静态变量

（1）静态变量在内存中存放在静态存储区，与对象的数据存放位置不同，是单独存放的。开辟后一直有效，直到程序结束。静态变量在内存中只有一份。
（2）静态变量不依赖于某个对象，而是属于类，所以访问方式特殊。引用静态变量的方法：
         通过类的名称（推荐）
         通过引用类的任一实例
（3）静态变量在程序加载时已初始化。
（4）静态变量实质上就是全局变量。

（2）静态方法

静态方法是类方法，调用时可以通过类名调用。
类的静态方法只能访问其他的静态成员，不能访问非静态成员。

（3）静态块

引用静态块的目的是为静态变量初始化。
静态代码段只执行一次，并且是在加载时执行。

2.final关键字

final 修饰符可应用于类、方法和变量。
final在应用于类、方法和变量时意义是不同的，但本质是一样的：final表示不可改变。
声明为final的变量不能被修改，因此也称为常量。
声明为final的方法不能被子类同名方法覆盖。
声明为final的类只能被实现一次，不能被继承。

3.this关键字

this一般用于类的方法定义中，代表调用该方法的对象。
关键字this与对象关联，用于指示当前对象。
当方法的参数或者方法中的局部变量与类的属性同名时，会产生冲突引起类的属性被屏蔽，此时需要通过“ this.属性名 ”的方式才能访问类的属性。

4.super关键字

表示当前对象的直接父类对象。
super有两种用途：
在子类的构造方法中调用父类的构造方法；
在子类方法中访问被隐藏的父类的属性或方法。
在创建子类对象时，系统可以自动调用父类无参的构造函数。
对于父类中带参数的构造函数，系统不能自动调用，只能在子类的构造函数中通过super()进行调用，此时，super()必须是在子类构造函数中的第一个执行语句。

六、对象数组

对象数组就是一个数组中的所有元素都是对象，声明对象数组与普通基本数据类型的数组一样，具体格式如下：类名[ ] 数组名 = new 类名[长度];