Java基础一

 

面向对象的程序设计是以解决问题域中所涉及的各种对象为中心的。主要包括概念：抽象、对象、类和封装、继承、多态性、消息、结构与关联。

下面将列出这些简单的概念理解：

1.抽象：其实就是抽出来事物的本质特性，暂且不必考虑其细节。

2.对象：它是客观存在的实体，有明确定义的状态和行为（细节）。

对象是封装了数据结构及可以施加在这些数据结构上的操作的封装体。属性和操作是对象的两大要素。

3.类：类是一组具有相同特性的对象成员的集合，用于创建相同属性和相同操作的对象（学生）。【类是对象的模版，但类是抽象的，对象是实体。通过对象，类的功能才能实现】

4.封装：就是把对象的属性和操作结合在一起，构成一个独立的封装体。通过封装把对象的实现细节对外界隐藏起来。

5.继承：一个类可以继承另一个类的属性和方法。通过将共同属性和方法抽象出来组件新的类，便于代码的重用。

6.多态性：不同类型的对象接受相同的消息是产生不同的行为。此处消息是对类中成员函数的调用，不同行为是指成员函数的不同实现。

7.消息：向某个对象发出的服务请求称作消息。对象提供的服务的信息格式称作消息协议。消息包括被请求的对象标识，被请求的服务标识，输入信息和应答信息。

8.结构与关联：一个系统一般由很多对象组成，对象之间并不是孤立的，而是存在各种关系，其中包括部分/整体、一般/特殊、实例连接、消息连接。

A.一般/特殊：也就是存在继承关系，或者泛化和特化关系

B.实例连接：对象之间的静态联系，通过对象属性来表达对象之间的依赖关系。对象之间的实例连接称为链接。对象类之间的实例连接称为关联。

C.消息连接：动态联系。一个对象发送消息请求另一个对象服务，接受消息的对象响应消息，执行相应的服务。

 

 

写这篇博客目的主要是想把自己在学习这些基础的东西过程中遇到的一些个人认为比较重要的，容易出错的东西做一记录，之所以写以上这几个概念开头，主要是因为学了段时间以后回头再看这些的时候突然很有感触，就写下来了。

 

 

1.类中的方法——方法的声明

A.方法名可是是任意标识符，命名规则与标识符命名规则相同

B.返回值类型说明符用来指定方法返回值类型，方法最多只能返回一个值

C.参数列表是方法接受的外来信息，列出一系列形式参数的类型和方法。

D.方法调用时必须有个实际参量与形式参数一一对应，而且实参变量的类型必须与对应的形式参数类型一致。

E.补充：成员变量在类中声明之后，可以再声明语句中赋值，不允许用另外的语句赋值，但是也可以在类的方法中赋值。

如下：为错误语句

public class smp{

Int a,b;

a=1;b=2;.......

}

正确的应该为：

public class smp{

Int a=1;

Int b=2;......

}或者在方法中赋值  

 

2.类中的方法——构造函数——构造函数的概念和作用

一个构造函数是类的一个特殊方法，他的作用是构造并初始化对象

A.构造函数的方法名与类名相同

B.构造函数没有返回类型，但可以携带0个1个或多个参数

C.构造函数的主要作用是完成对类对象的初始化工作

D.构造函数不能由编程人员显式的直接调用

E.当new一个类的新对象时，系统会自动调用该类的构造函数为新构造的对象初始化

F.实例化是执行的构造方法不仅用于初始化，还要分配内存和其他辅助作用

G.在创建对象（实例化）的过程中，按照构造方法需要分配存储空间，有了存储空间就创建了一个实体。构造方法以类为模板创建，所以对象是以类为模版创建的实体

H.构造方法所需的内存空间和类中包含的变量和方法有关，不尽和他们的数量有关，还和他们的功能、数据类型有关。

I.构造方法可以重载（引入了更多的灵活度）

下面是一个运用构造方法的实例：

//学生类
public class Student {
	private String name;//姓名
	private int age;//年龄
	private String major;//专业
	private int point;//分数
	private int grade;//年级
	public Student(String Name,String Major,int Age,int Grade,int Point){
		//带参构造函数，完成每个对象的初始值赋值
		this.name=Name;
		this.major=Major;
		this.age=Age;
		this.grade=Grade;
		this.point=Point;
	}
	public String getName(){
		return name;
	}
	public void setName(String Name){//设置姓名
		this.name=Name;
	}
	public String getMajor(){
		return major;
	}
	public void setMajor(String Major){//设置专业
		this.name=Major;
	}public int getAge(){
		return age;
	}
	public void setAge(int Age){//设置年龄
		this.age=Age;
	}public int getGrade(){
		return grade;
	}
	public void setGrade(int Grade){//设置年级
		this.grade=Grade;
	}public int getPoint(){
		return point;
	}
	public void setPoint(int Point){//设置分数
		this.point=Point;
	}
	public String toString(){//返回基本信息
		return name+","+major+",";
	}
}

   测试类

public class Test {

	public static void main(String[] args) {
		//构造一个数组，赋予它三个学生Student对象（可任意）
		Student st[]=new Student[3];
		st[0]=new Student("张三","信管",18,10,92);
		st[1]=new Student("李四","电商",20,11,88);
		st[2]=new Student("王五","国贸",19,12,96);
		System.out.println("输出学生信息如下：");
		for(int i=0;i<st.length;i++){
			Student stu = st[i];
			System.out.println("第"+i+"个学生信息："+stu.toString()+stu.getAge()+","+stu.getGrade()+","+stu.getPoint());
		}
		//修改学生成绩，全体减去5分
		for(int i=0;i<st.length;i++){
			st[i].setPoint(st[i].getPoint()-5);
		}
		//输出修改后的学生信息
		System.out.println("输出学生信息如下：");
		for(int i=0;i<st.length;i++){
			Student stu = st[i];
			System.out.println("第"+i+"个学生信息："+stu.toString()+stu.getAge()+","+stu.getGrade()+","+stu.getPoint());
		}
	}

}

测试结果：

输出学生信息如下：
第0个学生信息：张三,信管,18,10,92
第1个学生信息：李四,电商,20,11,88
第2个学生信息：王五,国贸,19,12,96
输出学生信息如下：
第0个学生信息：张三,信管,18,10,87
第1个学生信息：李四,电商,20,11,83
第2个学生信息：王五,国贸,19,12,91

 

 

3.方法中的参数传递——参数传递的方式

对于简单的数据类型来说，java实现的是值传递，方法接收参数的值，但不能改变这些参数的值。如果要改变参数的值，则需引用数据类型，因为引用数据类型传递给方法的是数据在内存中的地址，方法中对数据的操作可以改变数据的值。

下面通过一段简单的代码来介绍简单数据类型与引用数据类型的区别

 

//测试参数传递的方式
public class Pass {
		int number;
		//修改参数的方法
		public void changeInt(int number){
			number = 1;
		}
		public void changeRef(Pass pa){
			pa.number = 2;
		}
	}

 

测试类

public class Test {
	public static void main(String args[]){
		int Number = 0;
		System.out.println("Number的初值为："+Number);
		Pass pa = new Pass();
		pa.changeInt(Number);
		System.out.println("调用方法changeInt()后的值为："+Number);
		pa.number=3;
		System.out.println("类成员变量number的初值为："+pa.number);
		pa.changeRef(pa);
		System.out.println("调用方法changeRef()后的值为："+pa.number);
		
	}
} 

测试结果：

Number的初值为：0
调用方法changeInt()后的值为：0
类成员变量number的初值为：3
调用方法changeRef()后的值为：2

  

 

 

 

A.在主类Test中声明类Pass的对象pa，调用类中方法changeInt（number），但是结果却没有被改变。说明：对于简单的数据类型Number来说，java实现的是值传递，方法接收参数的值，但不能改变这些参数的值

B.当调用方法changeRef（pa），修改类中属性number的值，但方法调用后，参数值发生了改变。说明：如果要改变参数的值，则必须使用引用数据类型。

4.方法中的参数传递——对象作为参数的传递

简单的实例如下：

 

//学生类
public class Student {
	private String name;//姓名
	private int age;//年龄
	private String major;//专业
	private int point;//分数
	private int grade;//年级
	private boolean available;//成绩是否可以改动，true则可以，反之不行
	public Student(String Name,String Major,int Age,int Grade,int Point,boolean bool){
		//带参构造函数
		this.name=Name;
		this.major=Major;
		this.age=Age;
		this.grade=Grade;
		this.point=Point;
		this.available=bool;
	}

	public String toString(){//返回基本信息
		return name+","+major+","+age+","+grade+","+point;
	}
	public void siOk(){
		if(available==true){
			System.out.println("该学生成绩可以改。");
		}else{
			System.out.println("该学生成绩不可以改！");
		}
	}
}

   修改成绩的学生类

public class Alter {
	//获得自己的信息的方法
	//此处Student的对象st形参。
	public void getStudent(Student st){
		st.siOk();
	}
}

   测试类

public class Test {
	public static void main(String args[]){
		//获得学生基本信息
		Student stu = new Student("张三","信管",18,10,92,true);
		Student stu1 = new Student("李四","电商",20,11,88,false);
		System.out.println(stu.toString());
		//查看是否可改
		Alter al = new Alter();		
		al.getStudent(stu);
		System.out.println(stu1.toString());
		al.getStudent(stu1);
	}
}

 测试结果：

张三,信管,18,10,92
该学生成绩可以改。
李四,电商,20,11,88
该学生成绩不可以改！

 

5.java中的访问控制——static关键字的使用

A.静态变量称为类变量，非静态变量称为实例变量。静态变量时全局变量，属于整个类，不能定义在方法中

B.程序运行期间静态变量的内存单元不会被其他变量占用，不同对象的同名静态变量占据同一内存单元

C.由于不同对象的静态变量占据同一内存单元，不管创建多少对象，同名静态变量只能有一个。

D.静态变量的有点事不会喝其他变量的数据混淆，缺点是如果某个对象改变了它，将会影响其他对象的使用。

E.静态方法只能操作静态变量，非静态方法均可操作。

F.静态方法的代码随类的定义装载，是属于整个类的，不只属于某一个对象，既可以通过类的对象访问，也可以通过类名访问。非静态方法和非静态变量的只能通过类的对象访问。

下面是一段代码示例：

//测试类
public class Test {
	private static int number;//静态变量，统计对象个数
	private String name;
	public static void main(String[] args) {
		Test te = new Test("张三");
		te.useStatic();
		Test te1 = new Test("李四");
		te1.useStatic();
	}
	public Test(String Name){
		this.name=Name;
		number++;
	}
	public static void useStatic(){
		int i = 0;//正确，可以有自己的局部变量
		number++;//正确，静态方法可以使用静态变量
		staticMethod();//正确，可以调用静态方法
		name = "静态对象";//错误，不能使用实例变量
		resultMethod();//错误，不能调用实例方法
	}
	public static void staticMethod(){
		System.out.println("测试能被类中静态和非静态方法调用的静态方法");
	}
	public void resultMethod(){
		staticMethod();//正确，可以调用静态方法
		System.out.println("新建对象信息："+name);
		System.out.println("新建对象个数："+number);		
	}
}

 测试结果：

Exception in thread "main" java.lang.Error: Unresolved compilation problems: 
	Cannot make a static reference to the non-static field name
	Cannot make a static reference to the non-static method resultMethod() from the type Test

	at zwq04.Test.useStatic(Test.java:20)
	at zwq04.Test.main(Test.java:8)

 

 6.java中的访问控制——final关键字的使用

A.final成员：当你在类中定义变量时，在其前面加上final关键字，表示这个变量一旦被初始化便不可改变，对于基本类型来说是其值不可以改变，对于对象变量来说其引用不可以再变。其初始化可以在两个地方，一是其定义的地方，也就是说在final变量定义时直接给它赋值；二是在构造函数中。这两个地方只能选其一，不能同时。

B.final方法:将方法声明为final，则此方法不能扩展，也不允许任何从此类继承的类来重写这个方法，但是仍然可以继承这个方法，即直接使用。

C.final类：此类无法被继承，无需修改和扩展