JAVA期末复习3-面向对象（上）

学习目标：

1. 访问控制符级别
2. 方法重载
3. 构造方法
4. this关键字
5. static关键字
6. 对象与封装

---

学习内容：

访问控制符级别

default为默认级别

方法重载

//重载多个名称相同，但是参数的类型或个数不同的方法，
	public static int add(int x,int y) {
		return x+y;
	}

	public static int add(int x,int y,int z) {
		return x+y+z;
	}

	public static double add(double x,double y) {
		return x+y;
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int a=add(1,2);
		int b=add(1, 4, 6);
		double c=add(1.1, 2.3);
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
	}

构造方法

注意成员方法、构造方法、静态方法的区别！

如何写构造方法

// 构造方法
	//条件：同名，无参数返回值，无return返回一个值（可以return作为方法结束）
	//每个类必有一个构造方法，若无，系统自动加入一个无参数返回的构造方法,一旦为该类定义了构造方法，系统将不再提供默认的无参构造方法
class Person08 {
	public Person08() {
		System.out.println("调用了无参的构造方法");
	}
}

三种方法的调用

class Person09{
	int age;
	//构造方法
	//在方法名的前面没有返回值类型的声明
	public Person09(int a) {
		age=a;
	}
	//成员方法
	public void speak() {
		System.out.println("i am "+age+" old.");
	}
	//静态方法（后面再说）
	public static void say() {
		System.out.println("hello!!");
	}
}
public class example09 {
	public static void main(String[] args) {
		//静态方法调用
		Person09.say();
		//构造方法调用
		Person09 p=new Person09(18);
		//成员方法调用
		p.speak();
	}

}

this关键词

使用this的好处：

使用this的注意事项

使用例子：

public class example11 {
	public static void main(String[] args) {
		Person11 p=new Person11(18);
	}

}
class Person11{
	public Person11(){
		System.out.println("无参的构造方法被调用了");
	}
	public Person11(int age){
		this();//调用无参的构造方法
		System.out.println("有参的构造方法被调用了");
	}
}

利用this访问private属性

public class example10 {
	public static void main(String[] args) {
		Person10 p1 = new Person10(18); 
		Person10 p2 = new Person10("张三",32);
		p1.speak();
		p2.say();
	}

}
class Person10 {//重名编译不显示出错，运行出错
	// 声明String类型的变量name
	private String name;
	// 声明int类型的变量age
	private int age;
	// 定义有参构造方法
	public Person10(int age) {
		this.age = age;         // 为age属性赋值
	}
	public Person10(String name,int age){
		this.name = name;       // 为name属性赋值
		this.age = age;        // 为age属性赋值
	}
	// 定义 speak() 方法
	public void speak() {
		System.out.println("我今年" + age + "岁了!");
	}
	// 定义say()方法
	public void say(){
		System.out.println("我叫"+name+",今年" + age + "岁了!");
	}
}

static关键字

为什么使用static？

Java中的static关键字，用于修饰类的成员，如成员变量、成员方法以及代码块等，被static修饰的成员具备一些特殊性。比如被static关键字修饰的成员变量、方法可以被类直接访问，而不需要预先构造类的实例化对象，而且是被多个实例化对象共享的。

public class example12 {

	public static void main(String[] args) {
		Student.schoolName="beijing";
		Student stu1=new Student();
		Student stu2=new Student();
		stu1.schoolName="清华大学";
		stu2.schoolName="北京大学";
		System.out.println(stu1.schoolName);
		System.out.println(stu2.schoolName);
		System.out.println(Student.schoolName);
	}

}
class Student {
	static String schoolName;  // static只修饰成员变量
	public void speak() {
	}
}

输出：
北京大学
北京大学
北京大学

public class example13 {

	public static void main(String[] args) {
		//method 1
		Person13.say();//不用创建对象直接调用静态方法
		//method 2
		Person13 p=new Person13();
		Person13.say();
	}

}
class Person13{
	public static void say() {
		System.out.println("hello!!!");
	}
}

public class example14 {

	static{
		System.out.println("执行了测试类中的静态代码块");
	}
	public static void main(String[] args){
		/*
		 * 如果静态代码块定义在主类中，会优先于main()方法执行。
		 * 静态代码块定义在非主类中，会优先于构造方法执行。
		 * 当类被加载时，静态代码块会执行，并且只会执行一次。
		 * 开发时避免使用代码块
		 */
		// 实例化2个Person对象
		Person14 p1 = new Person14();
		Person14 p2 = new Person14();//static静态代码块只执行一次
	}

}
class Person14{
	public Person14() {
		System.out.println("调用了无参的构造方法");
	}
	static {
		System.out.println("执行了Person类中的静态代码块");
	}
}

输出：

对象与封装

在设计一个Java类时，应该对成员变量的访问作出一些限定，不允许外界随意访问，这就需要实现类的封装–private来实现

END