JAVA基础之封装继承（static关键字和super关键字）

Java语言有三大特征：

封装（encapsulation）：对外部不可见,隐藏对象的属性和实现细节。

继承（inheritance）：一个类继承另一个类的成员。

多态（Polymorphism）：每个对象表现的多样性。

访问权限

权限\使用范围	本类	同包中类或同包子类	不同包子类	不同包类
public	v	v	v	v
protected	v	v	v	x
默认[default]	v	v	x	x
private	v	x	x	x

封装

对成员变量私有化

封装成员变量两个步骤：

第一步： 添加private 修饰符，private修饰的成员变量就是私有成员变量，只能在类内部直接访问，类外不能直接访问。

第二步： 添加get和set方法

get方法表示访问私有属性的方法

public 属性类型 getXxx(){
return 属性;
}

set方法表示修改私有属性的值的方法

public void setXxx(参数类型 参数){
this.xxx = 参数;
}

static关键字

静态属性
所有本类对象所共有且相同的一个属性，是类的公用变量，不会随着对象的改变而改变的属性

静态方法
所有本类对象所共有且相同的一个公共方法，属于类方法，先于对象的方法，不依赖于对象，可以直接通过类名直接调用（类名.方法名()）。

使用注意事项：

​ 1 静态方法中可以直接访问静态变量，不能直接访问非静态变量。

​ 2 非静态方法中可以直接访问静态变量和静态方法。

​ 3 静态变量存在方法区中静态域中

代码块

代码块分为：局部代码块、动态代码块、静态代码块

局部代码块： 声明在方法中的代码块，执行时机与声明位置相关， 提前释放变量。

动态代码块： 又称构造代码块或实例代码块，声明在类体中的代码块，创建对象时自动执行一次，每创建一个对象就执行一次动态代码块。初始化工作。

静态代码块： 使用static关键字修饰的动态代码块，在类加载时自动执行，并只执行一次。

继承

在原有类的基础上，产生一个新的类，在新的类中可以访问原有类中的非私有成员，并且可以添加一些自己独有的成员，这个过程叫做继承

继承的好处

• 实现代码的重用和扩展
• 模拟现实世界的关系

类的继承的使用

使用extends关键实现两个类的继承关系

被继承的类：父类，超类，基类

继承的类：子类，派生类

继承符合: is a 关系

语法

public class FatherClass{
	//属性
	//方法
}
public class ChildClass extends FatherClass {
	//属性
	//方法
}

子类对象实例化过程

• 1 先实例化父类对象
  • 默认调用父类默认构造方法
• 2 再实例化子类对象

不能被子类继承的成员：

1）私有成员：私有成员不能被子类继承
2）构造方法：父类中的构造方法不能被子类继承，但是会在子类的构造方法中调用（子类的构造方法中默认第一条语句是调用父类的默认构造方法 super（）；）

继承的特点：

1）单继承：一个子类只能有一个父类,一个父类可以有多个子类
2）传递性：继承具有传递性

super关键字

super关键字：用法和this类似

this 表示当前对象的引用。

super表示当前父类对象的引用。

super的使用规则

1）super.属性：表示访问父类中的属性，当子类中定义了与父类同名的属性时，若想在子类中访问父类的同名属性，需要使用super.属性访问

2）super.方法：表示调用父类中的方法，在子类中需要调用父类中没有被重写的方法时，需要使用super.方法调用

3）super()： 表示调用父类的构造方法，注意：super()必须是子类构造方法中第一条语句
子类中构造方法默认第一条语句会调用父类的无参数构造方法super()，也可以手动调用父类中带参数的构造方法

方法重写(覆盖)

方法重载（overload）：

​ 1 同一个类中，方法名相同，参数列表不同（个数不同，类型不同，顺序不同）

​ 2 和返回值，访问修饰符无关。

方法重写

在继承过程中，子类中从父类继承来的方法无法满足自己的需求时，可以在子类中对父类方法进行完善，这个完善过程叫做方法重写(override)，方法的重写相当于在子类中覆盖父类中的方法。

• 1 在继承过程中，方法名、参数列表、返回值类型必须和父类相同
• 2 访问修饰符不能比父类严格
  java特殊 1.7 返回值可以和父类兼容就可以，必须是引用类型

p1 案例：

public class Animal {
    //属性
	String nickname;
	String color;
	String strain;

//默认构造方法
public Animal() {
	System.out.println("父类Animal的构造方法执行了..........");
}

//带参构造方法()
public Animal(String nickname,String color,String strain) {
	this.nickname=nickname;
	this.color=color;
	this.strain=strain;
}


//打印方法
protected Object printInfo() {
	System.out.println("本动物 昵称:"+nickname+" 颜色:"+color+" 品种:"+strain);
	return 10;
}
}

public class Dog extends Animal{
	int love;
	//默认构造方法
	public Dog() {
		super();//调用父类的默认构造方法
		System.out.println("Dog子类的构造方法执行了");
}
	//带参构造方法
	public Dog(String nickname,String color,String strain,int love) {
		super(nickname, color, strain);//调用父类的带参构造
		this.love=love;
	}

/**
 * 看家
 */
public void lookHome() {
	System.out.println(nickname+"正在给主人看家....");
}
/**
 * 重写 :覆盖
 * 1 方法名相同
 * 2 方法参数  返回值类型必须相同
 * 3 访问修饰符不能比父类严格
 * 
 * java特殊 1.7  返回值 可以和父类兼容就可以，必须是引用类型
 */

public String printInfo() {
	System.out.println("狗狗信息：昵称:"+super.nickname+" 颜色:"+super.color+" 品种:"+super.strain+" 亲密度:"+this.love);
	return "haha";
}
}

有关方法重写之后的调用：

​ 只要在子类中重写了父类的方法，通过子类对象调用该方法一定是子类重写的方法。