本文详细讲解了Java中的封装概念，包括如何控制用户对类的访问，使用import语句解决命名冲突，以及关键概念如包、继承、super关键字和方法覆写。还介绍了final关键字的作用。深入理解了权限控制和类的继承结构，有助于提升代码复用和安全性。
- 封装 : 控制用户对类的修改程度,隐藏属性和行为的具体实现,只提供公开的接口即可 简单来说,你只需要知道我能干什么,不需要知道我是怎么做的,也能够加强代码的安全性
1.2Importpackage : 软件包机制 * 限制的是编译之后的class文件的保存目录,和源文件无关 * eclipse中,源文件也必须在这个目录中,这是eclipse的问题,和package无关 * 而java中的package 只是规定class文件 * * 1 主要为了解决命名冲突问题 * 2 package语句必须出现在java源文件的第一行 * 3 一般采用公司域名倒叙的方式 * com.tledu.oa.system; * com.tledu.oa.pojo; * com.tledu.oa.dto; * 域名倒叙.项目名.模块名 * 4 带有package语句的java文件 应该这样编译 * javac -d 生成路径 字符编码 源文件路径 * javac -d ./ -encoding utf-8 xxxx.java * -d : disk 磁盘 * ./ : 代表当前目录 * 5 运行 * java 包名.类名 * public class Package_01 { public static void main(String[] args) { System.out.println("package"); } }package day_03._01_Package; public class Package_02 { public static void main(String[] args) { // 调用一个不是本包中的类,需要写类全名 // 包名.类名 day_03._01_Package.com.User user = new day_03._01_Package.com.User(); user.m1(); } }package day_03._01_Package; // 导入对应的这个类 // .* 是导入对应包下的所有类 import java.util.*; import day_03._01_Package.com.User; // java.lang.*; 下的所有类,为系统核心类,可以直接使用,不需要导入 /** * import 用于导入当前类中需要用到的其他类 * * 该语句 必须在package语句之下,class语句之上 * * public class Package_03 { public static void main(String[] args) { String str = "xxx"; // 调用一个不是本包中的类,需要写类全名 // 包名.类名 /** * 注意 : 写代码的时候,使用eclipse按空格 会自动导入对应的包 * * 如果程序没有问题,但是报错,可以查看一下,是否是导包错误了 */ User user = new User(); user.m1(); } }package day_03._01_Package; // 静态导入,访问一个类 的静态属性的时候,需要使用类名.静态属性访问 // 但是静态导入之后,就可以直接写静态属性访问 import static day_03._01_Package.com.User.*; import day_03._01_Package.com.User; public class Package_04 { public static void main(String[] args) { // 类名.静态变量名 System.out.println(User.a); // 因为静态导入了,所以可以直接写变量名 // 不建议使用,在当前类中,不容易看出来,这个变量到底是谁的 System.out.println(a); } }1.3权限控制
package day_03._02_PPP;
public class A {
// public : 哪都行
public static int a = 1;
// private : 除了当前类,那都不行
private static int b = 2;
// 默认 是包权限,同包可以访问
static int c = 3;
// 继承权限,要么同包,要么有继承关系
protected static int d = 4;
}
package day_03._02_PPP;
import day_03._02_PPP.pojo.User;
public class PPP_01 {
public static void main(String[] args) {
System.out.println(User.a);
// System.out.println(User.b);
// System.out.println(User.c);
// System.out.println(User.d);
System.out.println(A.a);
// System.out.println(A.b);
System.out.println(A.c);
System.out.println(A.d);
}
}
2.继承
2.1
package day_03._03_Extends;
/**
* 1 继承 :
* 继承 就是在已有类中派生出新的类,新的类能够吸收父类已有的属性和行为,并且还能扩展自己的属性和行为
*
* 2 继承特点
* java中 只支持单继承,不支持多继承 ,这样使java 的继承体系更加简单清晰
* 一个类只能有一个父类,但是一个类可以有很多子类
* 继承关系是可以进行传递的
*
* private私有化属性不能被继承
*
* 3 解决什么问题?
* 提高 代码的复用,提高开发效率
*
* 一个类如果没有显示继承另一个类,那么该类默认继承 Object
* java.lang.Object ,是java提供的根类(祖宗) ,也就意味着 Object中的所有属性是所有类都有的
*
* 4 怎么用
* 语法 [修饰符] class 类名 extends 父类名{
* 类体;
* }
*
*
public class Extends_01 {
public static void main(String[] args) {
SubClass subClass = new SubClass();
// 调用继承自父类的方法
subClass.m1();
// 调用自己的方法
subClass.m2();
// 因为所有类都直接间接继承Object,而toString就是Object中的方法
// 至于toString是干什么的,回来再说
subClass.toString();
}
}
package day_03._03_Extends;
public class SubClass extends SupClass{
public void m2(){
System.out.println("子类m2");
}
}package day_03._03_Extends;
public class SupClass {
public void m1(){
System.out.println("父类m1");
}
}
3.Super
super : 官方给的说法是,代表了父类型特征,可以理解为父类对象
通过子类中,可以使用super关键字,来标识父类,通过this来标识自己
1 不能再静态上下文中使用
2 用在构造方法或者成员方法中 ,区分子类和父类同名的变量和方法
super.xxx = xxx; super.m1();
3 用在子类构造方法中,调用父类的构造方法
super(参数); 必须出现在子类构造方法第一行
this(参数) : 也必须出现在第一行,所以 他们两个不能同时出现
如果 构造方法第一行 , 没有出现 this(参数) 也没有出现 super(参数)
则默认有个super() 调用父类的无参构造
public class Super_01 {
public static void main(String[] args) {
SubClass sub = new SubClass();
sub.test();
}
}3怎么用
package day_03._04_Super;
public class SupClass {
int i = 1;
public void m1(){
System.out.println("父类m1");
}
public SupClass(){
super();
System.out.println("父类构造");
}
public SupClass(int i){
super();
System.out.println("父类构造"+i);
}
}
package day_03._04_Super;
public class SubClass extends SupClass {
int i = 2;
public void m1(){
System.out.println("子类m1");
}
public void test(){
// 由于子类也有,所以默认使用子类的
System.out.println(i);
// 想使用父类的,需要使用super区分
System.out.println(super.i);
m1();
super.m1();
}
public SubClass(){
// 可以调用父类指定的构造方法,默认是调用无参
super(22);
System.out.println("子类构造");
}
}
package day_03._04_Super;
public class Super_02 {
private Super_02(){
}
}
// 构造方法私有化之后,不能被继承,因为子类构造方法中,需要调用父类构造方法
// 但是因为私有化的问题,导致子类调用不了
//class Test extends Super_02{
//
//}package day_03._04_Super;
/**
* 结果为 : 父类静态语句块,子类静态语句块,父类实例语句块,父类构造,子类实例语句块,子类构造
*
* @author 天亮教育-帅气多汁你泽哥
* @Date 2021年10月13日 下午12:10:15
*/
public class Super_03 {
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("父类构造");
}
}4.覆写
package day_03._05_Override;
/**
* override : 方法的覆写/重写
*
* 什么时候需要重写 : 当父类功能无法满足子类需求的时候,子类需要根据需求对方法进行重写
*
* 重写的必要条件
* 1 必须有继承关系的体系中
* 2 方法名必须一致 ,方法名不同,就是两个方法了,跟重写没有关系
* 3 参数列表必须一致,如果参数列表不一致,就是方法重载
* 4 返回值必须一致,返回值表示反馈的功能,不更改功能
* 5 不能比原方法有更宽泛的异常(错误不能越来越多)
* 6 不能比原方法拥有更低的访问权限
*
* 重写的意义 :
* 功能越来越强
* 错误越来越少
* 使用范围越来越广
*
* override和overload的区别
* 1 分别是什么
* 2 分别能干什么
* 3 区别
*
* 方法 覆写 特指成员方法,只有成员方法可以被覆写,和 静态方法,静态变量,成员变量 都没有关系
*
*
public class Override_01 {
public static void main(String[] args) {
Cat c = new Cat();
c.move();
}
}
class Animal{
public void move(){
System.out.println("动物移动");
}
}
class Cat extends Animal{
// @Override注解 标识该方法是覆写的父类的方法
// 如果加着该注解,方法如果不小心写错了,比如方法名拼写错误的时候,会提示有错
@Override
public void move() {
System.out.println("猫............在爬");
}
}5.Final
package day_03._06_Final;
/**
* final 是修饰符,表示最后的,最终的,不可更改的
*
* final修饰的类 不能被继承
* final修饰的方法 不能被覆写
* final修饰的变量 不能二次赋值,并且没有默认值
* final修饰的静态变量,一般叫常量 , 一般使用 public static final 修饰,常量名建议全部大写
*
*
public class Final_01 {
// 没有默认值,会报错
// final int a ;
final int i;
Final_01(int i) {
this.i = i;
// 不能二次赋值
// this.i = i;
}
}
class MyMath{
public static final double PI = 3.1415926;
}
//final class A{
//}
// 不能继承,因为A是最终的,使用final修饰了
//class B extends A{
//}
//class A{
// public final void m1(){
// }
//}
//class B extends A {
// @Override
// 不能覆写,因为m1使用final修饰 是最终的
// public void m1() {
// }
//}package day_03._06_Final;
/**
* 深入final : final修饰的引用类型,地址不能更改,和地址对应的数据 没有关系
*
*
public class Final_02 {
public static void main(String[] args) {
final int i = 1;
// i = 2;
final Customer c = new Customer("张三", 18);
// c中保存的地址,根据地址找到的数据是可以更改的,因为name又没有加final修饰
c.name = "李四";
// 因为c使用final修饰了,所以c不能再更改为其他值
// c = null;
// c = new Customer("张三", 18);
System.out.println(c.name);
System.out.println(c.age);
}
}
class Customer {
String name;
int age;
public Customer(String name, int age) {
super();
this.name = name;
this.age = age;
}
}
扫一扫
188
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
