面向对象(继承)

在讲面向对象(封装)之前我想先谈谈构造方法,以及他的重载.还有给成员变量赋值的两种方式,static关键字的使用和注意事项

(一)学习面向对象继承特征的准备.

(1):构造方法和构造方法的重载

什么是构造方法?作用是什么?

答案:构造方法是个对象的数据进行初始化的.

构造方法的格式是:

1,方法名和类名相同

2,没有返回值类型

3,没有具体的返回值return

什么事构造方法的重载?

答案:方法名相同,与返回值类型无关(构造方法没有返回值),只看参数列表

注意事项: 1,如果我们没有给出构造方法，系统将自动提供一个无参构造方法。 ,如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
所以这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法

(2):给成员变量赋值的两种不同方式以及具体代码的案例

构造方法和setXxx()方法getXxx()方法

构造方法是给对象中得属性进行初始化

setXxx是修改属性的值

案例:

<span style="font-size:18px;">/*
* A:案例演示
	* 需求：定义一个员工类Employee
	* 自己分析出几个成员，然后给出成员变量
		* 姓名name,工号id,工资salary 
	* 构造方法，
		* 空参和有参的
	* getXxx()setXxx()方法，
	* 以及一个显示所有成员信息的方法。并测试。
		* work 
*/</span>

<span style="font-size:18px;">class Test2_Employee {						//employee员工
	public static void main(String[] args) {
		Employee e = new Employee("令狐冲","9527",20000);
		e.work();
	}
}
/*
* A:案例演示
	* 需求：定义一个员工类Employee
	* 自己分析出几个成员，然后给出成员变量
		* 姓名name,工号id,工资salary 
	* 构造方法，
		* 空参和有参的
	* getXxx()setXxx()方法，
	* 以及一个显示所有成员信息的方法。并测试。
		* work 
*/
class Employee {
	private String name;					//姓名
	private String id;						//工号
	private double salary;					//工资

	public Employee() {}					//空参构造

	public Employee(String name, String id, double salary) {//有参构造
		this.name = name;
		this.id = id;
		this.salary = salary;
	}

	public void setName(String name) {		//设置姓名
		this.name = name;
	}

	public String getName() {				//获取姓名
		return name;
	}

	public void setId(String id) {			//设置id
		this.id = id;
	}

	public String getId() {					//获取id
		return id;
	}

	public void setSalary(double salary) {	//设置工资
		this.salary = salary;
	}
	
	public double getSalary() {				//获取工资
		return salary;
	}

	public void work() {
		System.out.println("我的姓名是:" + name + ",我的工号是:" + id + ",我的工资是:" + salary 
			+ ",我的工作内容是敲代码");
	}
}
	</span>

 

(3)static关键之的特点

satatic关键字有三个特点,

   1:随着类的加载而加载
    2:优先于对象存在
    3:被类的所有对象共享

值得注意的是被static修饰可以使用类名调用

 

这里提到static我就想在提一个知识点,那就是

静态变量和成员变量的区别

1:所属不同
    静态变量属于类，所以也称为为类变量
    成员变量属于对象，所以也称为实例变量(对象变量)
2:内存中位置不同
    静态变量存储于方法区的静态区
   成员变量存储于堆内存
3:内存出现时间不同
     静态变量随着类的加载而加载，随着类的消失而消失
     成员变量随着对象的创建而存在，随着对象的消失而消失
4:调用不同
     静态变量可以通过类名调用，也可以通过对象调用

   成员变量只能通过对 象名调用

 

 

(4)代码块特点:

java语言中分了四中代码块分别是:

局部代码块，构造代码块，静态代码块，同步代码块

其中各个代码快的作用和应用是:

1:局部代码块 
 在方法中出现；限定变量生命周期，及早释放，提高内存利用率
2:构造代码块 (初始化块)
在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
3:静态代码块 
在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。
一般用于加载驱动

 

注意:在继承的时候三个优先于解决代码块顺序问题

 

静态优先于非静态

父类优先于子类

构造代码块优先于构造函数

 

讲了这么多知识点,最重要的目的就是为能更快更好的去理解面向对象的第二个特点<继承>,现在就来详细的介绍面向对象继承的特征

 

(二)面向对象第二大特性(继承)

(1):继承

Java中,只支持类与类的但继承,也支持类的多层继承.

总的来说Java是支持多继承的(接口就可以)

继承:让类与类产生关系,子父类关系.

继承的好处;    

1:提高了代码的复用性
2:提高了代码的可维护性
3:让类与类之间产生了关系，是多态的前提

继承的弊端:

耦合性增强了

(2):this和super关键字的使用区别

1:this和super都代表什么
this:代表当前对象的引用,谁来调用我,我就代表谁
super:代表当前对象父类的引用（代表父类内存空间的标识，代表子类对象中存储父类成员的内存空间）
2:this和super的使用区别
a:调用成员变量
this.成员变量 调用本类的成员变量,也可以调用父类的成员变量
super.成员变量 调用父类的成员变量
b:调用构造方法
        this(...)    调用本类的构造方法
        super(...)    调用父类的构造方法
        c:调用成员方法
        this.成员方法 调用本类的成员方法,也可以调用父类的方法
        super.成员方法 调用父类的成员方法

 (2):继承中构造函数的关系

在继承的时候所以得子类都会去访问父类中的无参构造函数. 为什么回去访问??

 因为所以得子类在继承的时候都是需要去访问父类的数据,所以子类在初始化之前必须访问父类的构造函数先完成父类数据的初始化.

 (3):继承中成员方法关系

方法重写;

方法的声明一致的就会复写父类的方法,什么叫声明一致>?就是说子父类中出现一模一样的方法(返回值类型可以使子父类)

方法重写的注意事项;

1,父类中私有的方法不能被重写

2,子类的访问权限补习大于等于父类

3,静态必须静态访问,(准确的说,其实这个不算是方法的重写).

 

这里既然提到了重载和重写那么问题来了,请问两者的区别是什么?

方法重写,方法声明一致,与返回值类型无关(返回值一样的)

方法重载,  方法标签一致,与返回值类型有关(可以不一样)

 

(4):通过案例,来复习以上知识

/*

<span style="font-size:18px;font-weight: normal;">class Animal_2 {
	public static void main(String[] args) {
		Cat c1 = new Cat("花",4);
		System.out.println(c1.getColor() + "..." + c1.getLeg());
		c1.eat();
		c1.catchMouse();

		Dog d1 = new Dog("黑",2);
		System.out.println(d1.getColor() + "..." + d1.getLeg());
		d1.eat();
		d1.lookHome();
	}
}
class Animal {
	private String color;					//毛的颜色
	private int leg;						//腿的个数

	public Animal(){}

	public Animal(String color,int leg) {
		this.color = color;
		this.leg = leg;
	}

	public void setColor(String color) {	//设置颜色
		this.color = color;
	}

	public String getColor() {				//获取颜色
		return color;
	}

	public void setLeg(int leg) {			//设置腿的个数
		this.leg = leg;
	}

	public int getLeg() {					//获取腿的个数
		return leg;
	}

	public void eat() {						//吃饭
		System.out.println("吃饭");
	}
}

class Cat extends Animal {
	public Cat() {}							//空参构造

	public Cat(String color,int leg) {		//有参构造
		super(color,leg);
	}

	public void eat() {						//吃鱼
		System.out.println("猫吃鱼");
	}

	public void catchMouse() {				//抓老鼠
		System.out.println("抓老鼠");
	}
}

class Dog extends Animal {
	public Dog() {}							//空参构造

	public Dog(String color,int leg) {		//有参构造
		super(color,leg);
	}

	public void eat() {						//吃肉
		System.out.println("狗吃肉");
	}

	public void lookHome() {				//看家
		System.out.println("看家");
	}
}</span>