Java面向对象：封装——类与对象
类与对象
- 1.类与对象的介绍与定义
- 2.类成员初始化
-
- （1）默认初始化
- （2）构造方法对类字段初始化
- （3）this 的使用与代码块初始化
- 3.类成员函数 toString的使用
- 5.包与全限定类名
- 6.static修饰与public、private修饰
-
- （1）static的使用
- （2）访问限定符
- 7.Java面向对象之 封装
====================================================================================
1.类与对象的介绍与定义
- 类与对象是面向对象程序设计中的核心编程；
- 世间万物或具体或抽象；皆可对象；需要定义好对象的属性和行为；以此可以完成某件事；对象与引用介绍 跳转链接
- 类：类是自定义的数据类型，实例化出来的变量我们成为对象；类是用来对一些实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)；
- 使用class关键字来定义类：
// 创建类
class ClassName{
field; // 字段(属性) 或者 成员变量
method（）; // 行为 或者 成员方法
}
- 类名注意采用大驼峰定义
- 一个.java文件当中可以定义多个类，但必须有一个以public修饰的类；
- main方法所在的类必须要使用public修饰
- public修饰的类必须要和文件名相同
- new 关键字用于创建一个对象的实例.
- 使用 . 来访问对象中的属性和方法.
- 同一个类可以创建多个实例.
例：
// 在同一个包中创建的类，都可以被一个主类的主方法调用；（下例中，在Dog类中定义的该对象属性、行为；在ClassPractice类中主类的主函数中进行Dog对象实例化，进而初始化和调用方法）
package objectClass;
/**
* @Author: 19261
* @Date: 2021/9/3 17:07
*/
//通过创建特定的类，表示实际的对象特征；
public class Dog {
//属性
public String name; //属性1：名字
public int age; //属性2：年龄
public String breed;//属性3：品种
//方法/行为
public void eat(){
System.out.println(name+"正在吃饭!");
}
public void play(){
System.out.println(name+"正在玩耍！");
}
public void introduce(){
System.out.println(name+"是"+breed+"品种,"+"今年"+age+"岁了！");
}
}
package objectClass;
/**
* @Author: 19261
* @Date: 2021/9/1 19:34
*/
public class ClassPractice {
public static void main(String[] args) {
//对象实例化
//对象属性初始化：通过 . 解引用操作
//方法行为的调用：通过 . 调用该对象封装类的方法，完成某种行为
Dog dog1=new Dog();
dog1.name="小呆";
dog1.age=1;
dog1.breed="金毛";
Dog dog2=new Dog();
dog2.name="旺财";
dog2.age=2;
dog2.breed="吉娃娃";
Dog dog3=new Dog();
dog3.name="迪加";
dog3.age=1;
dog3.breed="边牧";
dog1.introduce();
dog2.introduce();
dog3.introduce();
dog1.eat();
dog2.play();
dog3.play();
}
}
2.类成员初始化
（1）默认初始化
// 默认初始化： 只要创建了类对象，Java中都会先把对象成员自动设置为默认值；
- 数字类型（包括整数和浮点数）默认值为0；
- 布尔类型默认为false；
- 引用类型默认为null；
public class Test {
public byte a;
public short b;
public char c;
public int d;
public long e;
public double f;
public boolean l;
public String s;
public int[] arr;
}
public class ClassPractice {
public static void main(String[] args) {
Test t=new Test();
System.out.println(t.a);
System.out.println(t.b);
System.out.println(t.c);
System.out.println(t.d);
System.out.println(t.e);
System.out.println(t.f);
System.out.println(t.l);
System.out.println(t.s);
System.out.println(t.arr);
}
}
（2）构造方法对类字段初始化
- 类对象的构造方法必须与类名相同；
- 若类中已经定义了有参构造方法，则不在生成无参构造的对象；
- 类中的构造方法没有return返回值，默认返回对象本身；
- 构造方法支持重载（通过参数个数和类型的不同实现重载）
- 构造方法不需要显式调用，在类对象通过new关键字创建时 自动调用执行；
class Student{
//成员/属性
public String name;
public int age;
//构造方法
public Student(){
name="小明";
age=18;
}
public Student(int a){
age=a;
}
public Student(String n){
name=n;
}
public Student(String n,int a){
name=n;
age=a;
}
public void show(){
System.out.println(name+" "+age);
}
}
public class ClassPractice {
public static void main(String[] args) {
//对象实例化
//对象属性初始化：通过 . 解引用操作
//方法行为的调用：通过 . 调用该对象封装类的方法，完成某种行为
Student s1=new Student();
s1.show();
Student s2=new Student("小红");
s2.show();
Student s3=new Student(2);
s3.show();
Student s4=new Student("小白",19);
s4.show();
}
}
// 创建对象时，通过 new() 调用实现自动调用构造方法初始化；
// 在创建对象时，先默认初始化；然后再通过构造方法初始化；没有通过构造方法初始化的成员属性，仍保留默认值；
（3）this 的使用与代码块初始化
- this 表示当前对象本身的引用；
- this 在成员方法中，只能只想该对象，不能再指向别的对象，具有final属性；
- 可以通过this 调用自身的构造方法；
- this 只能在成员方法中使用，必须放在第一行，第一个使用；
- 使用场景：当形参与成员名相同时，必须加以区分，使用this . 属性 ——表示指向对象本身；
- java编译器给每个“成员方法“增加了一个隐藏的引用类型参数，该引用参数指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中中所有成员变量的操作，都是通过该引用去访问。
// 代码块相当于无参的构造方法；并且构造方法后执行于代码块；
public class Point {
public int x;
public int y;
//相当于没有参数的构造方法，也是在new 创建对象时自动调用
{
x=0;
y=1;
}
//构造方法在默认初始化和代码块初始化之后执行的初始化
public Point(int x,int y){
//当形参和类成员属性名字相同时，使用Java中的this 指向对象的该属性
this.x=x;
// 通过this调用它自身构造方法
//this(x);
this.y=y;
}
public void show(){
System.out.println("点("+x+","+y+")");
}
}
public class ClassPractice {
public static void main(String[] args) {
Point p=new Point(1,2);
p.show();
}
}
- // 在IDEA 中可以自动生成构造方法：
Alt+Insert ->Constructor -> 选择属性 ->点击ok 完成创建；
3.类成员函数 toString的使用
- 每一个类中都可以创建一个toString()方法 用于查看所创建对象的属性；
- 调用自己创建的toString()方法：System.out.println(对象名）/ 对象名 . toString();
- IDEA 中可以自动生成toString()方法：Alt+Insert ->toString() -> 选择全部属性 ->点击ok 完成创建；
- 自动生成的toString()方法 使用的时候直接 利用输出语句调用System.out.println(对象名）；
// public String toString(){
// return "点("+this.x+","+this.y+")";
// }
@Override
public String toString() {
return "Point{" +
"x=" + x +
", y=" + y +
'}';
}
5.包与全限定类名
- 包：：为了更好的管理类，把多个类或者收集在一起成为一组，称为软件包。
- 包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，
- 在同一个工程中允许存在相同名称的类，只要处在不同的包中即可；
- // 自定义包 在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包；
- 编写代码时，需要创建隶属于别的包（自定义/Java系统包）的对象，需要将类导入包中：
- 1.通过全限定类名创建：
java.util.Data data=new Data(); - 2.通过使用 import语句导入包.
import java.util.Data;
//import java.util.*;表示导入Java类工具包util中的所有类；
- 1.通过全限定类名创建：
// 常见的Java包：
- java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
- java.lang.reflect:java 反射编程包;
- java.net:进行网络编程开发包。
- java.sql:进行数据库开发的支持包。
- java.util:是java提供的工具程序包。(集合类等) 非常重要
- java.io:I/O编程开发包。
6.static修饰与public、private修饰
（1）static的使用
- 在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。
- static 的使用：
- 被static修饰的成员或属性，是类的属性/成员/字段，可以通过 对象.属性 访问，但一般通过 类名.属性访问；
- 类的成员的生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)。JDK7及以前，HotSpot(Java虚拟机)中存储在方法区，JDK8及之后，类变量存储在Java堆中；
- 被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的（类名 . 成员方法）。
- 静态方法没有隐藏的this引用参数，因此不能在静态方法中访问任何非静态成员变量
- 可以在非静态方法中调用静态成员方法；
- 被static修饰的成员或属性，是类的属性/成员/字段，可以通过 对象.属性 访问，但一般通过 类名.属性访问；
public class Computer{
public int id;
private static String cpu;
public String memory;
public Computer() {
id=123;
cpu="MAR";
memory="100G";
}
public void show(){
System.out.println(id);
//可以在非静态方法中调用静态成员方法
this.replace("MMM");
}
public static void replace(String s){
//this.id=n;
cpu=s;
System.out.println(cpu);
}
@Override
public String toString() {
return "Computer{" +
"id=" + id +
", memory='" + memory + '\'' +
", cpu='" + cpu + '\''+
'}';
}
}
public class ClassPractice {
public static void main(String[] args) {
Computer c=new Computer();
System.out.println(c);
c.show();
Computer.replace("max");
}
}
- 实例代码块与static代码块：
//实例代码块
{
this.id=333;
this.memory="50G";
this.cpu="MAR20";
System.out.println("执行实例代码块");
}
//static代码块
static{
cpu="NULL";
System.out.println("执行static代码块");
}
// 通过代码运行结果可知：
- 由static修饰的静态代码块不管生成多少个对象，其只会执行一次静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的；
（2）访问限定符
- Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制那些方法或者属性需要在类外直接使用；
- // 表格中有三角符号表示该限定符修饰的可以访问；
public：可以理解为一个人的外貌特征，谁都可以看得到
default: 对于自己家族中不是什么秘密，对于其他人来说就是隐私了
private：只有自己知道，其他人都不知道 - 访问权限除了可以限定类中成员的可见性，也可以控制类的可见性
例：
7.Java面向对象之 封装
- 面相对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性。
- **封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。**控制用户对类的修改和访问数据的程度。 适当的封装可以让程式码更容易理解和维护，也加强了程式码的安全性。
- 封装是一种信息隐藏技术，在java中通过关键字private，protected和public实现封装。