封装 & 代码块 & 继承 & super关键字 & 包 & 访问权限 & 重写与重载

我要宣布一件大事，我有粉丝了，哈哈哈哈哈哈哈哈啊哈哈哈啊哈，激动的❤，颤抖的手，我要继续加油了
今天第一次用md绘制表格，淡定

封装

什么是封装：在类中，对于不想被类外直接访问的成员变量，进行私有化，同时对外提供一个公有的方法为了访问私有的成员。

封装成员变量两个步骤：

1 添加private

2 添加get和set方法

类设计原则
成员变量(属性)私有化(用private修饰)，添加get和set方法
公开方法(用public修饰)
exp:

private 属性类型 Xxx;
get方法表示访问私有属性的方法：
public 属性类型 getXxx(){
  	return 属性;
}
set方法表示修改私有属性的值的方法：
public void setXxx(参数类型 参数){
  	this.xxx = 参数;
}

代码块

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

局部代码块：声明在方法中的代码块，执行时机与声明位置相关。（了解） 提前释放变量，控制变量的作用域
//main方法内
{

}

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

}

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

}

继承

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

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

继承的类：子类，派生类

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

public class Person {
	String name;
    int age;
	String birthday;
	
	public void showInfo() {
		System.out.println("姓名:"+name+" 年龄:"+age+" 出生日期:"+birthday);
	}
}

public class Student extends Person{
	
	String school;
	public void study() {
		System.out.println(name+"好好学习天天向上");
	}
}

super关键字

super表示父类的引用

1）super.属性：表示访问父类中的属性，当子类中定义了与父类同名的属性时，若想在子类中访问父类的同名属性，需要使用super.属性访问
2）super.方法：表示调用父类中的方法，在子类中需要调用父类中没有被重写的方法时，需要使用super.方法调用
3）super()：表示调用父类的构造方法，注意：super()必须是子类构造方法中第一条语句
子类中构造方法默认第一条语句会调用父类的无参数构造方法super()，也可以手动调用父类中带参数的构造方法

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;
	}
	
	//打印方法
	public void printInfo() {
		System.out.println("本动物 昵称:"+nickname+" 颜色:"+color+" 品种:"+strain);
	}
}

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+"正在给主人看家....");
		System.out.println("昵称："+super.nickname);
		System.out.println("颜色:"+super.color);
		System.out.println("品种:"+super.strain);
		System.out.println("亲密度:"+this.love);
		super.printInfo();
	}
}

public class Test {
	public static void main(String[] args) {
		Dog afu=new Dog();
		afu.nickname="阿福";
		afu.color="黑色";
		afu.strain="哈士奇";
		afu.love=100;
		afu.lookHome();
		System.out.println("----------------------------------------");
		//调用Dog的带参构造
		Dog xiaohei=new Dog("小黑", "白色", "泰迪", 100);
		xiaohei.lookHome();
	}
}

包

创建包
package com.qf.test;

public class Employee {
    private String name;        //姓名
    private int age;                //年龄
    private double salary;     //薪水

  	public Employee(){
        
    }
    public Employee(String name, int age, double salary){    //构造方法
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
 } 
 导入包
 为使用定义在不同包中的Java类，需要import语句来引入所需要的类。
语法格式：
import  package1[.package2…].类名

import com.qf.test.Employee;

public class PackageDemo {	
    public static void main(String args[]){
        Employee employee = new Employee();
    }
}

注意：

	要导入某个包中的所有类可以用：包名.*

	例如：import  java.util.*;

	在同一包中的类可以直接互相引用，无需import语句。 

访问权限

	本类	同包中类或同包子类	不同包子类	不同包类
public	ok	ok	ok	ok
protected	ok	ok	ok	error
默认[default]	ok	ok	error	error
private	ok	error	error	error

个人记忆法 protected保护子类，default只保护包
使用原则：

• 修饰类时：只能public 或 默认的
• 修饰成员变量和方法：可以使用public 、默认、protected 、private
• 局部变量不能访问权限修饰符。

重写与重载

方法的重载：Overload，在同一个类中,方法名相同，参数类别不同，互为重载方法。

方法的重写：Override，在继承过程中，在子类中重写父类中继承来的方法，方法名相同，参数列表、返回值必须相同，访问权限不能比父类严格。