JavaSE(2):java面向对象（上）

二、java面向对象基础及高级语法

 

1、方法：Method

理解：一段可重复使用的代码段，程序中完成独立功能的一段代码的集合。

格式： 修饰符 返回值类型 方法名(参数列表) {  代码块(方法体)  }

调用： 对象名.方法名(实参列表)    静态方法调用：类名.方法名（实参列表）

重载（overload）：在同一个类中，允许存在一个以上的同名方法，只要他们的参数列表不同即可（包括参数个数，类型，顺序，与返回值无关，只看参数列表（方法名相同前提）），方法再调用的时候根据实际传递的参数列表自动匹配相应的函数。

参数传递：主要是引用类型数据的参数传递过程，引用类型传递的是变量名在栈中的地址（指向对象再堆中的数据）。

TestOverLoad.java

public class TestOverLoad {
	void a(){}
	
	void a(int a){}
	
	//int a(){}  //报错：视为和void a(){}相同的方法，即为返回值不作为判断函数是否相同的依据
	
}

 

2、可变参数

作用：方法中可以接受的 参数不再是固定的个数，而是随具体需求传递的多少来决定

格式： 返回值类型 方法名（参数类型 ... 形式参数） {  方法体 }

特点：可变参数只能出现在参数列表的最后面； … 位于变量类型和变量名之间，前后有无空格都可以；调用时，编译器为该可变参数隐含地创建一个数组，在方法体中以数组形式访问可变参数。

TestVariousParameter.java

 

import java.util.Arrays;

public class TestVariousParameter {
	static void test(String name,int ... aa){
		//可变参数作为数组处理
		System.out.println( name + Arrays.toString(aa) ); 
	}
	
	public static void main(String[] args) {
		test("xx",12,123,45,67);  // xx[12, 123, 45, 67]
		test("xx",12,34);		  // xx[12, 34]
	}
}

3、面向对象基础（Object-Oriented，OO思想）

原理：将任何事物都抽象成一个独立（当然这个个体还是和其他个体会有联系，此处的独立指的是该个体的方法和数据都是这个个体自己本身独立使用的）的个体，将其数据和方法放在一起，封装其中，组合形成一种新的复合数据类型。

特征：面向对象的三大特征：封装（Encapsulation）、继承（Inheritance）、多态（Polymorphism）

 

4、类class和对象object

A)  概念：类(class)和对象(object)是面向对象方法的核心概念。类是对一类事物描述，是抽象的、概念上的定义；对象是实际存在的该类事物的每个个体，因而也称实例(instance)。类是java语言的最小编程单位，是java的基础。类是抽象的一类事物，不含有某个具体个体的数据，但是它可以由抽象化具体实例化一个对象，产生一个实实在在的个体，这个个体就具有了类所给它限定的数据和方法。

 

B)  对象：类是对象的模板，对象时类的一个实体，又称实例；属性和操作是对象的两大要素，属性即数据，是静态的，也叫成员变量（变量），数据成员(数据)。操作常称为方法、行为，是动态的对象的动作、功能，也叫成员函数。

 

C) 类的声明、定义、创建、使用：

 

TestClass.java

 

 

//类的声明、定义、创建、使用：
public class TestClass { //类的声明
	 //声明属性，<修饰符>  类型   属性名 [=初值] ; 
	 private int age;             //声明private变量 age，若不初始化，会在创建对象时默认初始化
	 public String name = "Lila"; //声明public变量 name
	 //修饰符 private: 该属性只能由该类的方法访问。修饰符 public: 该属性可以被该类以外的方法访问。

	 //声明方法
	 public void print(){
		 System.out.println("姓名:" + name + ",年龄:" + age);
	 }
	 
	 
	 //类的使用
	 public static void main(String[] args) {
		TestClass test = new TestClass(); //new 创建class对象
		test.name = "lala";   //访问对象的属性
		test.print();         //范文对象的方法
		//输出：姓名:lala,年龄:0 （此处年龄未初始化，在new对象的时候int数据默认初始化为0）
	}
}

 

D)  构造方法：用来构造类的实例，每一个类都有一个默认的无参的构造器，但是一旦类的定义者显式定义了一个或多个构造方法，系统将不再提供默认的构造方法，得使用new调用；字段field：类或者对象所包含的对象；方法method：类或对象的行为。构造方法也可以重载，通常实现在创建对象实例的时候对实例的属性赋初值功能。构造方法不含返回值，所以也不能写return语句，在构造方法里不含返回值的概念是不同于“void”的，在定义构造方法时加了“void”，结果这个方法就不再被自动调了（这一点上可以认为构造器不是方法）。构造方法的作用：当一个类的实例对象刚产生时，这个类的构造方法就会被自动调用。且构造器的名称必须与类名相同。

 

E)  static关键字：随着类的加载而加载；优先于类的对象存在；被所有对象所共享，一个对象修改static属性，其他同类对象的该属性都修改；可以直接用类名.（点）调用。注意：静态方法只能访问静态属性，但是非静态方法可以访问静态属性，静态方法中不能使用super、this关键字，因为static可以无须对象就调用，直接在类加载的时候被载入，不寄托于实例上，而是直接依靠在类上。主方法main必须是static的（若用类名调用静态的main方法，会陷入死循环出现内存溢出，jvm自动停止）。

 

F） 匿名对象：没有名字的对象，创建一个对象，但是没有赋给一个变量。匿名对象只能使用一次，用完就被销毁了，因为没有名字，用户无法找到它，在创建后游离在堆内存中无法掌握，所以无法再次使用，但是匿名对象可以作为函数实参传递。

 

G） this关键字：this表示当前对象的引用。谁访问到含有this关键字的语句，那么this就是指的谁（对象）。通常用在构造器中 ，且构造器的互相调用也是用this完成，但是此时this语句必须在构造器中的第一行。

 

H） 封装：两个含义，首先是，将对象的状态和行为看成一个整体，将二者存放在一个独立的模块（class）中；二是信息隐藏，使用者对类内部定义的属性(对象的成员变量)的直接操作会导致数据的错误、混乱或安全性问题。所以需要对类内部数据进行封装保存，不能随意调用改变。Java中通过将数据声明为私有的(private)，再提供公开的（public）方法:getXXX和setXXX实现对该属性的操作。

 

I） 访问修饰符：

修饰符	同一个类	同一个包	子类	整体
private	Yes
default	Yes	Yes
protected	Yes	Yes	Yes
public	Yes	Yes	Yes	Yes

 

 

J） 类的设计分析：根据要求写出类所包含的所有字段，字段通常用private修饰，并提供相应的get和set方法访问，添加若干个重载的构造器，添加相应的方法，类中所有的方法都不要直接处理（输出打印），而是交给调用者去处理。

 

K） package语句：package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。包对应于文件系统的目录，package语句中，用‘ .’ 来指明包(目录)的层次；包通常用小写单词，类名首字母通常大写。

 

J） import语句：为使用定义在不同包中的Java类，需用import语句来引入所需要的类。Import语句告诉编译器到哪里去寻找类。如import   p1.*; //表示引入p1包中的所有类。

 

K） 继承：继承是从一般到特殊的过程，也是多态的基础，java语言只支持单继承（防止不知道方法是继承自哪个父类的，调用的时候错乱），但是可以多层继承，Object是所有类的超类。不过接口可以多继承。extends关键字为继承，子类又叫派生类、扩展类，父类又叫基类。java.lang.Object是所有类的要么直接要么间接的父类。子类对象实例化时必须先调用父类的构造器在调用自身的构造器。注：子类继承自父类，则子类拥有了父类所有的域和方法，但是这并不代表子类继承了所有的父类方法和域，因为private修饰的私有方法和域子类没有继承，只是拥有，且不具备访问权限（语义有点绕），还有父类的构造器也不被继承。

一个子类只能继承其父类的可访问的成员，并且该子类没有覆盖或者说隐藏父类中的那些可访问成员。所以，一个类的成员就是指在这个类中所声明的属性和方法，再加上从其父类继承而来的属性和方法。也就是说，子类是不能继承父类的私有成员的。
虽然子类不继承父类中的私有成员，但是在父类中生命的这些私有成员仍然是子类类型对象的一部分。因为在实例化对象的时候，只初始化在当前类中所声明的属性明显是不足够，

的，还需要初始化其父类中所有声明的属性。在实例化的过程中，jvm需要为对象的类及其父类中所有定义的属性分配空间，包括父类中声明的私有成员。

 

L） 子类对父类的访问及方法的重写（覆写Override）

当父类中某个方法不适合子类本身的特征行为时就应该在子类中覆写父类中应该改变的方法。在子类中调用已被覆写的父类的同名方法使用spuer（参数列表）调用，子类方法前加上@Override能通过编译，则表明方法是覆写的。

方法覆写原则：1、方法名、参数、返回值相同。2、子类方法不能缩小父类方法的访问权限。3、子类方法不能抛出比父类更多的异常（子类可以不抛出异常）。4、存在于父类与子类之间。5、方法被定义为final不能被重写。

注意重载（overload）和覆写（override）的区别。

 

M） super关键字及调用父类的构造方法

Super是父类对象的引用，使用super可以调用父类被覆盖的方法，也可以调用父类的构造器。子类本类中调用另一个重载的构造器使用this（参数列表），子类构造器总调用父类的构造器使用super（参数列表），但是super语句必须放在第一行，若不显示的（super）调用父类的构造器，java会默认在创建子类对象时调用父类的无参构造器，若显示的指定调用某个父类构造器，就取消调用父类的无参构造器，而调用指定的那个。

 

N） 多态

指同一个实体同时具有多种形式（父类的，子类的，间接父类的等等，有继承关系的）。编译时，类型由声明该变量时使用的类型决定，但是运行时由实际赋给该变量的类型的对象决定，如果编译时类型和运行时类型不同（即声明的类型和new时的类型不同），就出现多态，但是无继承关系，就直接非法。

原理：动态绑定技术，程序调用方法再运行期间才动态绑定，引用变量所指向的真正的实例对象的方法，也就是当前在内存中运行的那个对象的方法，而不是引用变量的类型中定义的方法。

作用：把不同的子类都当做父类对象同等看待，屏蔽了个体之间的差异，写出通用的代码，但是在运行时，执行各自相应的操作。这一切由继承作为基础。

编译时的多态，就是方法的重载；而运行时的多态，就是方法的父类子类间的重写。

TestOverride.java

 

public class TestOverride {
	
	public static void main(String[] args) {
		Parent parent = new Parent();
		//parent.aa(); 该句无法调用，aa是私有方法，不能跨类访问
		parent.bb(); //可以访问公有方法
		
		System.out.println("------------------");
		
		Parent son = new Son(); //多态
		//son.aa(); 同样无法调用
		son.bb();
	}
	
}

@SuppressWarnings("unused")
class Parent{
	private String name;
	private int age;
	public int sex;
	
	public Parent() {
		System.out.println("parent无参构造器！");
	}
	
	
	private void aa(){
		System.out.println("parent的aa私有方法");
	}
	
	public void bb(){
		System.out.println("parent的bb公有方法");
	}
}
@SuppressWarnings("unused")
class Son extends Parent {
	
	private int mark;
	
	public Son() {
		System.out.println("son无参构造器！！");
	}
	
	//@Override 加入该注解会编译出错，可见aa不是重写的，即不能覆盖父类的私有方法，只能先继承再覆写
	private void aa() {
		System.out.println("son的aa私有方法");
	}
	
	@Override //可见，这是一个覆写
	public void bb() {
		//super.bb(); 这一句可以访问到父类被覆写的方法
		System.out.println("son的bb公有方法");
	}
}
/**
 * 输出结果：
 * parent无参构造器！
 * parent的bb公有方法
 * ------------------
 * parent无参构造器！
 * son无参构造器！！
 * son的bb公有方法
 *
 */

M） 引用变量类型的转换

向上转型：父类名称 父类实例 = 子类实例； 自动完成

向下转型: 子类名称 子类对象 = （子类名称） 父类实例 ； 强制完成

instanceof：判断变量名此时真正的类型是不是当前给出的类。若对象只声明，而不初始化，给内存，的话，instanceof无意义，返回false。Instanceof使用时，只要是该类的的对象或是该类的子类的对象，都会返回true。

TestInstanceof.java.

 

/**
 * 输出结果：
 * a是类A的对象
 * b是类B的对象
 * n是类B的对象
 * n是类A的对象
 * false
 * 说明：多态的时候，instanceof可以检测是父类对象，也可以检测到是子类的对象,
 * 若对象只声明，而不初始化，给内存，的话，instanceof无意义，返回false
 */
public class TestInstanceof {
	
	public static void main(String[] args) {
		A a = new A();
		B b = new B();
		A n = new B();
		A x = null;
		
		if(a instanceof A){
			System.out.println("a是类A的对象");
		}
		
		if(b instanceof B){
			System.out.println("b是类B的对象");
		}
		
		if(n instanceof B){
			System.out.println("n是类B的对象");
		}else if(n instanceof A){
			System.out.println("n是类A的对象"); 
		}
		
		if(n instanceof A){
			System.out.println("n是类A的对象"); 
		}else if(n instanceof B){
			System.out.println("n是类B的对象");
		}
		
		System.out.println(x instanceof A);
		
	}
	
}

class A{}

class B extends A {}