java 封装 继承 final super 方法覆写

一 封装

1.1 封装的概念

        封装是把对象的所有组成部分组合在一起，封装使用访问控制符将类的数据隐藏起来，控制用户对类的修改和访问数据的程度,只提供公开的接口即可.

1.2 封装的作用

        适当的封装可以让代码更容易理解和维护，也加强了代码的安全性。

1.3 Package包机制

        限制的是编译之后的class文件的保存目录,和源文件无关,eclipse中,源文件也必须在这个目录中,这是eclipse中的问题,和package无关

        java中的package,只规定class文件

1.4 Package的作用

1 主要是为了解决命名冲突问题
                 2 package语句必须出现在java源文件的第一行 
                 3 一般采用公司域名倒叙的方式
                  com.xxx.xxx.xxx;
                   域名倒叙.项目名.模块名
               4 带有package语句的java文件 应该这样编译
               javac -d 生成路径 字符编码 源文件路径
               javac -d ./ -encoding utf-8 xxxx.java
                   -d : disk 磁盘
                   ./ : 代表当前目录
               5 运行
                   java 包名.类名

1.5 类的调用

1  调用一个不是本包中的类,需要写类全名:包名.类名

        eg:day_03._01_Package.com.User user = new day_03._01_Package.com.User();

2  import 用于导入当前类中需要用到的其他类,该语句 必须在package语句之下,class语句之上

        eg:import day_03._01_Package.com.User;

 3  .* 是导入对应包下的所有类

        eg:import java.util.*;

4 java.lang.*; 下的所有类,为系统核心类,可以直接使用,不需要导入

5 静态导入,访问一个类 的静态属性的时候,需要使用类名.静态属性访问,但是静态导入之后,就可以直接写静态属性访问

eg:import static day_03._01_Package.com.User.*;

二 访问控制符

访问控制符	同一类中	同一包中	同一子类中	其他
private	是	否	否	否
default	是	是	否	否
protected	是	是	是	否
public	是	是	是	是

public class A {
	    // public : 哪都行
		public static int a = 1;
		// private : 除了当前类,哪都不行
		private static int b = 2;
		// 默认 是包权限,同包可以访问
		static int c = 3;
		// 继承权限,要么同包,要么有继承关系
		protected static int d = 4;
}

三 继承

3.1 继承概念

        继承是从已有的类中派生出新的类，新的类能吸收已有类的属性和行为，并能扩展新的属性和行为。

3.2 继承作用

        提高代码的复用,提高开发效率

3.3 继承语法

        [修饰符] class 类名 extends 父类名{类体;}

3.4 java中继承特点

1. Java是单继承的，不支持多继承。这样使得Java的继承关系很简单，一个类只能有一个父类，易于管理程序。同时一个类可以实现多个接口，从而克服单继承的缺点。
2. 继承关系是传递的
3. private修饰的成员变量或方法是不能被继承的

public class Extends_01 {
public static void main(String[] args) {
	subClass subClass = new subClass();
	// 调用继承自父类的方法
	subClass.m1();
	// 调用自己的方法
	subClass.m2();
	// 因为所有类都直接间接继承Object,而toString就是Object中的方法
	// 至于toString是干什么的,回来再说
	subClass.toString();
}
}
//父类
public class supClass {
	public void m1(){
		System.out.println("父类m1");
	}
}
//子类
public class subClass extends supClass {
	public void m2(){
		System.out.println("子类m2");
}
}

四 super

4.1 概念

       官方给的说法是,代表了父类特征,可以理解成父类对象,通过子类中,可以使用super关键字,来标识父类使用this关键字来标识自己.

4.2 注意点

1 不能再静态上下文中使用

2 用在构造方法或成员方法中,区分父类和子类同名的变量和方法

        super.xxx = xxx;  super.m1();

3 用在子类构造方法中,调用父类的构造方法

        super(参数);   必须出现在子类构造方法第一行

        this(参数) : 也必须出现在第一行,所以 他们两个不能同时出现

        如果 构造方法第一行 , 没有出现 this(参数) 也没有出现 super(参数)  

        则默认有个super()  调用父类的无参构造

     4   构造方法私有化之后,不能被继承,因为子类构造方法中,需要调用父类构造方法
 但是因为私有化的问题,导致子类调用不了

例子:

执行顺序:静态语句块>实例语句块>构造方法

子类创建对象是,调用父类的super()构造方法,所以先初始化父类的属性,在初始化子类的属性

所以下列代码执行结果为:父类静态语句块,子类静态语句块,父类实例语句块,父类构造,子类实例语句块,子类构造

public class Super_05 {

	public static void main(String[] args) {
		new Sub();
	}
}

class Sub extends Sup {
	static {
		System.out.println("子类静态语句块");
	}

	{
		System.out.println("子类实例语句块");
	}

	public Sub() {
		System.out.println("子类构造");
	}
}

class Sup {
	static {
		System.out.println("父类静态语句块");
	}
	{
		System.out.println("父类实例语句块");
	}

	public Sup() {
		System.out.println("父类构造");
	}


}

五 方法覆写/重写

5.1 方法覆写的原因

        在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。

5.2 方法重写的必要条件

1 必须在有继承关系的体系中
2 方法名必须一致,方法名不同就是两个方法了.
3 参数列表必须一致,参数列表不一致就是方法重载了.
4 返回值必须一致,返回值表示反馈的功能,不更改功能
5 不能比原方法有更宽泛的异常(错误不能越来越多)
6 不能比原方法拥有更低的访问权限

5.3 方法重写的意义

功能越来越强,错误越来越少,使用范围越来越广.ianl

六 Final 

final 是修饰符,表示最后的,最终的,不可更改的
final修饰的类 不能被继承
final修饰的方法 不能被覆写
final修饰的变量 不能二次赋值,并且没有默认值
final修饰的静态变量,一般叫常量 , 一般使用 public static final 修饰,常量名建议全部大写

final修饰的引用类型,地址不能更改,和地址对应的数据 没有关系