本文详细介绍了Java中的包机制，包括包的作用、语法、命名规范及常用的系统包。接着讲解了访问修饰符的四种类型及其访问范围，强调了public、protected、default和private的使用场景。然后深入探讨了面向对象的封装概念，通过示例展示了如何进行数据隐藏和提供公共访问接口。最后，讨论了继承的基础知识，包括继承的优势、使用注意事项以及构造器的调用顺序。
1、包机制
1、1 包的三大作用
- 区分名字相同的类
- 当类很多时，可以更好的管理类
- 控制访问范围
1、2 包的基本语法
package 包名1.包名2...;
package：关键字，表示打包。
1、3 包的命名
- 只能包含数字、字母、下划线、小圆点。且不能以数字开头，不能数关键字或保留字
- 一般公司域名倒写命名，如：com.daidu.baike
com.公司名.项目名.业务名模块名
1、4常用的包
- java.lang.* ：基本包，使用是不要用导入
- java.util.* ：系统提供的工具包，如Scanner
- java.net.* ：网络包
- java.awt.* ：界面开发用的包，GUI
1、5 包的引入
语法：
import 包名；
1、import 包名1.包名2.类名； // 引入指定的类
2、import 包名1.包名2.*； // 引入包名2所有的类。
1、6 注意事项和使用细节
- package 的作用是声明当前类所在的包，需要放在类的最前前面，一个public类最多之能有一句package
- import指令放在package语句下面。
2、访问修饰符
java提供了四种访问修饰符，用于控制方法和属性的访问权限
- public ：公开的，
- protected ：受保护级别
- 默认级别
- private ：私有级别，不对外公开
四种访问修饰符的访问范围：
| 访问级别 | 访问修饰符 | 同类（本类） | 同包 | 子类 | 不同包 |
|---|---|---|---|---|---|
| 公开 | public | ✔ | ✔ | ✔ | ✔ |
| 受保护 | protected | ✔ | ✔ | ✔ | ✘ |
| 默认 | default | ✔ | ✔ | ✘ | ✘ |
| 私有 | private | ✔ | ✘ | ✘ | ✘ |
访问修饰符使用注意事项
- 当成员是方法或者属性时，该成员有四种访问权限：public、protected、默认、private
- 当成员是类是，该成员只用两种访问权限：public、默认。
3、面向对象之封装
3、1 封装概念
**封装（encapsulation）**就是把抽象出的数据[属性]和对数据的操作[方法]封装在一起，数据被保护在内部，程序的其他部分只能通过被授权的操作[方法]才能对数据进行操作
- 封装可以隐藏内部方法的实现细节
- 可以对数据进行验证，保证安全合理
package com.muyu.javase.object.encapsulation;
//面向对象之封装
/*
1、不能随便查看人的年龄，工资等隐私
2、对设置的年龄进行合理的验证，年龄合理就进行设置，否则使用默认
3、年龄范围在1-120之间，工资不能直接查看，name的长度在2-6字符
*/
public class EncapsulationDemo1 {
public static void main(String[] args) {
Person person = new Person();
person.setName("jack");
person.setAge(26);
person.setSalary(16000);
String name = person.getName();
int age = person.getAge();
double salary = person.getSalary();
System.out.println("姓名："+name+";年龄："+age+";薪资："+salary);
}
}
class Person{
public String name;
private int age;
private double salary;
//快速创建方法，快捷键 alt+insert >>> Getter and Setter。
public String getName() {
return name;
}
public void setName(String name) {//验证name，name的长度在2-6字符
if(name.length() <= 6 && name.length() >= 2){
this.name = name;
}else {
System.out.println("姓名无效");
}
}
public int getAge() {
return age;
}
public void setAge(int age) {//验证年龄，年龄范围在1-120之间
if(age >= 1 && age <= 120){
this.age = age;
}else {
System.out.println("年龄无效，默认年龄18");
this.age = 18;
}
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
3、2 封装的步骤
- 将属性进行私有化【不能直接修改内容】
- 提供一个公共的set方法，用对对私有的属性进行验证并操作。
public void setXxx(数据类型 参数名){
//业务逻辑
属性 = 参数名;
}
- 提供公共的get方法，用户获取属性值。
public getXxx(){
//业务逻辑
return 属性名;
}
- 将构造器与setXxx结合：
package com.muyu.javase.object.encapsulation;
public class EncapsulationDemo2 {
public static void main(String[] args) {
Person2 person2 = new Person2("Tom",25,13000);
String name = person2.getName();
int age = person2.getAge();
double salary = person2.getSalary();
System.out.println("姓名："+name+"; 年龄："+age+"; 薪资："+salary);
}
}
class Person2{
public String name;
private int age;
private double salary;
//构造器
public Person2(String name,int age,double salary){
this.setName(name);
this.setAge(age);
this.setSalary(salary);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
3、3 封装的使用注意事项
4、面向对象之继承
4、1 继承的概念
继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为
继承的基本语法：
class 子类名 extends 父类名{
//代码块
}
继承的优势是：
- 提高代码的复用性
- 提高代码的扩展性和维护性
4、2 继承的使用注意事项
- 子类继承了父类的所有属性和方法，父类的非私有属性和方法，子类可以直接访问，但是父类的私有属性和方法不能在子类直接访问，需要通过父类提供的公共方法才能访问。
package com.muyu.javase.object.extends_obj;
public class ExtemdsDemo1 {
public int n1 = 100;
int n2 = 200;
protected int n3 = 300;
private int n4 = 400;
public ExtemdsDemo1(){
System.out.println("父类构造器执行。。。。。");
}
public int getN4() {
return n4;
}
public void setN4(int n4) {
this.n4 = n4;
}
}
//=========================
package com.muyu.javase.object.extends_obj;
public class SubExtemdsDemo1 extends ExtemdsDemo1{
public SubExtemdsDemo1(){
System.out.println("sub...构造器执行");
}
public void say(){
System.out.println(n1+";"+n2+";"+n3+";");
//直接访问 n4会报错；
int n4 = getN4();
System.out.println("n4："+n4);
}
}
//============================
package com.muyu.javase.object.extends_obj;
public class TextExtendsDemo1 {
public static void main(String[] args) {
SubExtemdsDemo1 subdemo1 = new SubExtemdsDemo1();
subdemo1.say();
}
}
//---->
/*
父类构造器执行。。。。。
sub...构造器执行
100;200;300;
n4：400
*/
- 子类必须先调用父类的构造器，完成父类的初始化后，再调用子类的构造器，完成子类的初始化；
- 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会先去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中使用super去指定使用父类的构造器，并完成父类的初始化，否则编译不会完成。
- super在使用使用时，需要放在构造器的第一行
- super()和this()都只能放在构造器的第一行，因此这两个方法不能共存在一个构造器。
- this(参数)：调用本类中另一种形式的构造函数（应该为构造函数中的第一条语句）；
- super(参数)：调用父类中的某一个构造函数（应该为构造函数中的第一条语句）
package com.muyu.javase.object.extends_obj;
public class ExtemdsDemo2 {
public String name;
public int age;
//父类构造器
public ExtemdsDemo2(String name,int age) {
System.out.println("父类构造器执行");
}
}
//=========================
package com.muyu.javase.object.extends_obj;
public class SubExtemdsDemo2 extends ExtemdsDemo2 {
//子类构造器
public SubExtemdsDemo2(String name, int age) {
super(name, age); //指定父类的构造器
System.out.println("子类构造器执行");
}
}
//====================================
package com.muyu.javase.object.extends_obj;
public class TextExtendsDemo2 {
public static void main(String[] args) {
//实例化子类
SubExtemdsDemo2 smith = new SubExtemdsDemo2("Smith", 16);
}
}
- Java中所有类都是Object类的子类，Object是所有类的基类。
- 父类构造器的调用不限于直接父类，会一直往上追溯到Object类（顶级父类）。
- 子类最多只能直接继承一个父类，即Java中是单继承机制，不支持多继承。
- 不能滥用继承，子类和父类之间必须满足 is a 的关系。
4、3 继承的本质
- 子类继承父类，实例化子类，在加载类信息时，会追溯到Object类
- 加载完类信息后，从父类到子类依次在对象空间中开辟空间存储类信息
- 返回对象地址
（1）（2）（3）加载类信息，追溯到Object类，开辟对象空间0x1001
（4）存储父类属性（对应常量池地址）
（5）存储子类属性（对应常量池地址）
（6）返回对象空间地址0x1001
待续…………
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
