面向对象基础

 

学习日志_面向对象基础	//部分内容来自《java程序设计》机械工业出版社
Java语言_类和对象
{
	类是对某类对象的抽象描述，是该类对象的模板，对象是类的实例。
	面向对象的三个特征：封装、继承和多态。

	<1>类和对象的定义
	{
		①类的创建：
		
		类是一种引用数据类型，它描述了该类对象的状态和行为。
		其定义的一般语法形式如下：
			class 类名	//class是类定义的关键字
			{
				语句;
			}
		例：
		class Person
		{
			String name;
			int age;

			void sleep()
			{
				System.out.println("ZZzzz...");
			}
		}

		②对象的创建和使用：
		对象是实例化的类，假如类是图纸，那么对象就是通过图纸制造出来的汽车。
		该汽车具备图纸上所有功能和状态。
		创建对象的语法形式如下：
			类名 对象名 = new 类名();//new是建造对象的过程。
		例:
			/*
				对象的创建和使用示例
			*/

			class Person	//定义Person类
			{
				String name = "张三";
				int age = 20;
				
				void sleep()
				{
					System.out.println("ZZzzz...");
				}
			}

			public class PersonTest
			{
				public static void main(String[] args)
				{
					Person man = new Person();	//创建Person类的对象
					System.out.println("姓名："+man.name);//通过 对象名.类成员 的形式调用相关参数
					System.out.println("年龄："+man.age);

					man.sleep();	//通过man对象调用Person类中的sleep方法
				}
			}
		③封装：
		为了实现封装，java语言定义了多种访问权限修饰符，包括public（公用）、protected（保护）
		和private（私有）。
		修饰符public修饰的成员具有最大的使用权限，所有能访问其所属类的代码都可以访问它；
		而修饰符private修饰的成员只能在其所属的类中访问。

		
	}
	<2>数据成员的初始化
	{
		①构造函数：
		一般用于初始化类的对象，其方法名必须与所属类的类名完全相同。
		创建类的对象时，系统会自动调用其构造方法。
		例：
			/*
				构造函数示例
			*/
			class Person
			{
				String name;
				int age;
				Person(String x,int y)	//初始化Person类中的成员变量
				{
					name = x;
					age =y;
				}

				void getInfo()
				{
					System.out.println("姓名 = "+name+"\t 年龄 = "+age);
				}
			}


			public class PersonTest2
			{
				public static void main(String[] args)
				{
					Person man = new Person("李四",20);

					man.getInfo();
				}
			}

		②this关键字
		代表当前对象的引用。
		上述示例也可以写成下面这样，增加了代码的阅读性。
		例：
			/*
				this关键字示例
			*/
			class Person
			{
				String name;
				int age;
				Person(String name,int age)	
				{
					this.name = name;	//用this指明了当前对象的引用。
					this.age =age;
				}

				void getInfo()
				{
					System.out.println("姓名 = "+name+"\t 年龄 = "+age);
				}
			}


			public class PersonTest2
			{
				public static void main(String[] args)
				{
					Person man = new Person("李四",20);

					man.getInfo();
				}
			}
		
		③static关键字
		关键字static可以用来修饰类的数据成员或方法。如果将关键字static放在一个数据
		成员变量声明前，该变量就成为静态变量（也称类变量）；如果将关键字static放在
		一个方法定义前，该方法就成为静态方法（也称类方法）。
		
		static关键字的特点：
		1、随着类的加载而加载。
		2、优先于对象存在。
		3、被所有对象共享。
		4、可以直接被类名调用。
		
		例：
			/*
				static关键字应用
			*/
			class Person
			{
				static String name = "张三";
				static int age = 21;

				public static void getInfo()
				{
					System.out.println("姓名 = "+name+"\t 年龄 = "+age);
				}
			}


			public class PersonTest2
			{
				public static void main(String[] args)
				{
					Person.getInfo();
					Person.name = "李四";
					Person.age =20;
					Person.getInfo();
				}
			}
		注意：
		静态方法只能访问静态成员。
		静态方法中不可以定义this、super关键字。
	}
	
	<3>继承和多态
	{
		继承是java语言支持代码重用及多态的重要机制。通过继承，可以在现有类的基础上派生出
		新类，新类将共享现有类的属性和行为特征，并且还可以添加新的特性和行为。
		java中只支持单继承，但是可以实现多个接口。
		
		①继承与子类
		java语言中，子类为指明继承的父类，需要使用关键字extends。
		具体语法格式如下：
			class 子类名 extends 父类名
			{
				语句;
			}

		例：
			/*
				继承与子类
			*/
			class Person		//创建父类
			{
				String name;
				int age;

				void setName(String name)
				{
					this.name = name;
				}
				void setAge(int age)
				{
					this.age = age;
				}
				void getInfo()
				{
					System.out.println("姓名= "+name);
					System.out.println("年龄= "+age);
				}
			}


			class Student extends Person	//子类student继承于person类，同时也继承了他里面的成员和方法
			{
				void sleep()		//子类里面特有的方法。
				{
					System.out.println("ZZzzz...");
				}
			}

			public class InheritTest
			{
				public static void main(String[] args)
				{
					Student st = new Student(); //创建子类对象

					st.setName("张三");
					st.setAge(20);
					st.getInfo();
					st.sleep();
				}
			}
		②方法的覆盖
		java语言中，只有实例方法可以覆盖（也称重写）。方法覆盖时，必须注意子类中的方法应该
		与父类中被覆盖的方法有相同的方法名、返回值类型和形式参数列表（对应的形参名可以不同）。
		如果对应形式参数类型或形式参数个数不同，则是对同名方法的重载。

		例：
			/*
				重写示例
			*/

			class Person
			{
				public void readBook(int x)
				{
					System.out.println("Good Morning!");
				}
			}

			class Student extends Person
			{
				public void readBook(int x)//重写父类中的方法
				{
					System.out.println("早上好！");
				}
			}


			public class RepeatWrite
			{
				public static void main(String[] args)
				{
					Student st = new Student();
					
					st.readBook(1);
				}
			}
		
		③final关键字
		关键字final可用来修饰变量（包括数据成员和局部变量等）、方法和类，被final修饰
		的变量、方法和类是最终的、不可改变的。
		例：
		public static final PI = 3.14; //相当于全局常量

		④instanceof关键字
		运算符instanceof的作用是检查某个对象的实际类型是否是某个指定类或派生于指定类、
		实现了指定接口。如果是，该对象不为null，则返回true，否则返回false。
		其语法形式如下：
			对象 instanceof 类名
		

		⑤抽象类和抽象方法
		1、抽象方法一定在抽象类中。
		2，抽象方法和抽象类必须用abstract关键词修饰。
		3、抽象类不可以用new创建对象，因为调用抽象方法没有意义。
		4、抽象类中的方法要被使用，必须由子类重写其所有的抽象方法后，建立子类对象调用。
		   如果子类只覆盖了部分抽象方法。那么该子类还是一个抽象类。
		例：
			abstract class A	//建立抽象类
			{
				public abstract void f();//定义抽象方法
			}

			class B extends A
			{
				public void g()//错误，类B声明为抽象的，或者实现类A中的抽象方法
				{}
			}

			class C extends A
			{
				public void f()//正确，实现了类A中的抽象方法
				{}
			}
		⑥接口 interface
		接口是对外暴露的规则，程序的功能扩展，可以用来多实现，类与接口之间是实现关系，而且
		类继承一个类的同时还可以实现多个接口。接口和接口之间可以有继承关系，基本功能定义在
		类中，扩展功能定义在接口中。用implements关键字来实现接口。
		
		例：
			/*
				接口示例
			*/
			class Person
			{
				private String name;
				private int age;
				
				Person(String name,int age)
				{
					this.name = name;
					this.age = age;
				}
				public void inFo()
				{
					System.out.println("姓名 = "+ name + "\t 年龄 = " + age);
				}
			}

			interface Study	//定义接口类
			{
				public void readBook();
			}

			class Student extends Person implements Study	//实现接口，可以实现多个，用","分隔
			{
				Student(String name,int age)
				{
					super(name,age);
				}

				public void readBook()
				{
					System.out.println("English!");
				}
			}

			public class InterfaceTest
			{
				public static void main(String[] args)
				{
					Student st = new Student("张三",20);
					st.inFo();
					st.readBook();		
				}
			}
		⑦多态
		java语言中，通过方法覆盖可以在具有继承关系的多个类中定义名称相同但操作不同
		的多个方法，而多态指的正是程序运行时判断执行其中哪个方法的能力。
		例：
			/*
				多态运行示例
			*/
			class StudentClass
			{
				public void className()
				{
					System.out.println("班级名称");
				}	
			}

			class StudentClassOne extends StudentClass
			{
				public void className()
				{
					System.out.println("一班");
				}
			}
			class StudentClassTwo extends StudentClass
			{
				public void className()
				{
					System.out.println("二班");
				}
			}

			class StudentClassThree extends StudentClass
			{
				public void className()
				{
					System.out.println("三班");
				}
			}

			public class DuoTaiTest
			{
				public static void main(String[] args)
				{
					StudentClassOne st1 = new StudentClassOne();
					StudentClassTwo st2 = new StudentClassTwo();
					StudentClassThree st3 = new StudentClassThree();
					choose(st1);
					choose(st2);
					choose(st3);
				}

				public static void choose(StudentClass st)
				{
					st.className();
				}
			}

		⑧内部类
		java语言中，可以在一个类的内部定义另一个类，这个在其他类中定义的类叫做内部类
		内部类访问规则：
		1、内部类可以直接访问外部类中的成员，包括私有。
		2、外部类要访问内部类，必须建立内部类对象。
		创建内部类对象语法形式如下：
			外部类名.内部类名 对象名 = new 外部类名().new 内部类名;
		例：
			/*
				内部类的定义
			*/
			class OuterClass	//定义外部类
			{
				String str="OuterClass";
				class InnerClass	//定义内部类
				{
					String str="InnerClass";

					void print()
					{
						System.out.println(str);
						System.out.println(OuterClass.this.str);
					}
				}
			}

			public class InnerClassTest
			{
				public static void main(String[] args) 
				{		
					//创建内部类对象
					OuterClass.InnerClass oi=new OuterClass().new InnerClass();
					oi.print();
				}

			}
			
			匿名内部类
			1、匿名内部类就是内部类的简写格式
			2、定义匿名内部类的前提是内部类必须是继承一个类或者实现接口
			3、匿名内部类其实就是一个带内容的匿名子类对象
			4、匿名内部类定义格式：new 父类或者接口(){定义子类内容}
			例：
				/*
					匿名内部类示例
				*/

				interface Student
				{
					void readBook();	
				}

				class OutClass
				{
					private String name;
					OutClass(String name)
					{
						this.name = name;
					}
					public void show()
					{
						System.out.println("姓名= " + name);
					}
					Student inner()
					{
						return new Student()
						{
							public void readBook()
							{
								show();
								System.out.println("English...");
							}
						};
					}
				}

				public class StudentClass
				{
					public static void main(String[] args)
					{
						new OutClass("张三").inner().readBook();
					}
				} 

	} 
}//Java语言_类和对象结束，有错误请大家指正，谢谢。