浅析类与对象&封装

面向对象

综述：

类与对象

封装

继承

接口

多态

一、类和对象的基本概念
在Java中一切皆对象，一切都围绕对象进行，找对象、建对象，用对象等

1、类：把具有相同属性和行为的一类对象抽象为类。类是抽象概念，如人类、犬类等，无法具体到每个实体。

2、对象：某个类的一个实体，当有了对象后，这些属性便有了属性值，行为也就有了相应的意义，即object。

类是描述某一对象的统称，对象是这个类的一个实例而已。有类之后就能根据这个类来产生具体的对象。一类对象所具备的共同属性和行为（方法）都在类中定义。

有下列举例：

定义类：自己创建一个复合数据类型

语法： public class 类名{ }

class 类名称 {
 
成员变量/ 实例变量；
 
成员方法；
 

注意⚠️：

1： Java程序中的基本单位是类

2： 定义的类 不一定是都具有属性和方法的类 ，也可以是一些功能类（例如：Math、Random、System etc.）

内容： 学生类( 姓名 年龄 学号 | 上课 考试 学习 查看信息 )

属性：表达数据的信息；通常使用（变量/常量）表示

格式：

数据类型 数据变量名;

final 数据类型 数据变量名;

方法：表达行为/功能的逻辑 通常使用一段代码表示 { } (方法)

格式： 修饰符 返回值类型 方法名(参数列表){ // 方法体 }

除此属性和方法之外还包括：

构造方法

构造代码块

静态属性（变量/常量）

静态方法

静态代码块

创建对象： 使用自己定义复合数据类型创建变量，这种叫做对象变量

格式： 类名 对象名 = new 类名();

变量：属性

            参数

 某个{ }中的局部变量

方法中的局部变量

循环中局部变量

条件语句中局部变量

代码块中局部变量

名词解释

public class Test {
    public static void main(String[] args) {
        //创建一个实例化对象
        Person per1 = new Person();
        //通过对象来调用实例变量、成员方法
        per1.name = "小勇";
        per1.age = 18;
        per1.sex = "男";
        per1.print();
        Person per2 = new Person();
        per2.print();
    }
}
class Person{
    //成员变量（实例变量)，在堆中的每个对象中存储，通过对象调用
    String name;//默认值为null
    int age;//默认值为0
    String sex;//默认值为null
    //成员方法（实例方法），在JVM的方法区中存储，通过对象调用
    void eat(String food){
        System.out.println(name+"正在吃"+food);
    }
    void print(){
        System.out.println("name:"+name+", age:"+age+", sex:"+sex);
    }

封装：

一、封装的概念

java中封装的理解：

我们在程序设计的时候就追求“高内聚、低耦合”的模式；

高内聚：类的内部数据操作细节都由自己完成，不允许外部干涉；

低耦合：仅对外部暴露少量的方法用于使用。

总结下来，封装即为隐藏对象内部的复杂性、只对外公开简单的接口。便于外界调用从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来，这就是封装的设计思想。在Java中通过权限修饰符关键字private、protected和public实现封装。

实现封装的手段：

1、访问权限修饰符：在代码编译期间作用代码可以使用的范围 ，限制代码的使用范围

public ： 整个项目下都可以访问

private ： 只能在类的括号中使用访问

protected ： 只能在同包下 / 不同包的子类中可以访问

缺省不写： 只能在同包下

访问权限修饰符可以修饰：

类 ： public 缺省不写

接口：public 缺省不写

属性： 四种皆可

方法： 四种皆可

构造方法： 四种皆可

比如，我创建了一个学生类，在学生类中定义一些私有的属性

那么我在另一个类中创建一个学生类的对象，这个对象对应的对象变量名不能调用学生类中

属性来赋值或者使用。

二、封装的使用

作用：提高代码的安全性

通过一个属性感受封装：

public class A{
    int age;
}
 
public static void main(String[] args){
 
    A a = new A();
    a.age = 500;
}

在这里设置一个A类，有一个年龄属性，但是在主函数里面给年龄设置值的时候，可以胡乱的设置一个值，几百几千的违背常理的设置都不会报错，这个时候就可以使用封装了

public class A{
    private int age;
 
    
    //提供一个返回年龄的方法
    public int getAge(){
        return age;
    }
 
    //提供一个处理年龄误差的方法
    public void setAge(int age){
        if(age<80){
            age=18;
        }else{
            this.age = age;
        }
    }
}
 
 
public static void main(String[] args){
 
    A a = new A;
    a.getAge(81);
system.uot.println(a.setAge);

上面的代码，对于age属性来说，我加了private。这样外界对他的访问就受到了限制，现在我还想加上其他的限制条件，但是在属性本身上没有办法再加了，所以我们通过定义方法来进行条件的添加。

special notice !  !

{封: 给属性和方法设定权限 ，其他类中就不能直接使用了}

{可以封装属性，不然错误数据设置给属性}

{装： 打包}

{可以在类中提供 不受限制的方法来访问属性 或者 给属性赋值}

通过[set&get 方法

带参数的构造方法]

有例如下

public class Student{
String name;
private int age;
private int id;
private int score;
final int n = 10;//Variable 'n' might not have been initialized
static final int sn = 100;
static int num;
public Student(String name, int age, int id, int score){
this.name = name;
this.age = age;
this.id = id;
this.score = score;
}
// 给属性赋值
public void setName(String name){
this.name = name;
}
public void setAge(int age){
if(age < 0){
System.err.println ("输入的年龄有误！");
return;
}
this.age = age;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
}
class StuManage{
static void staticMethod(){
System.out.println ("静态方法 ");
}
public static void main(String[] args){
Student stu = new Student ("张三", 20, 1, 100);
// stu.age=-10;
// stu.id=1;
// stu.score=100;
// stu.score=100;
// stu.name="";// 'name' has private access in 'com09.oop.zyf0927.Student
// System.out.println (stu.getAge ());
// stu.setName ("张三");
// stu.setAge (-10);
// Student.name = "张三";// Non-static field 'name' cannot be referenced from a
static context
Student stu1 = new Student ("李四", 20, 2, 100);
// 静态的属性变量 只有一份 属于类 不管谁调用都是同一份
stu1.num = 300;
Student.num = 100;
stu.num = 200;
System.out.println (stu.num);
System.out.println (Student.num);
System.out.println (stu.num);
System.out.println (stu1.num);
// 对象成员属性每个对象都有自己独立的一份
stu.name = "张三";
stu1.name = "李四";
System.out.println (stu.name);
System.out.println (stu1.name);
StuManage.staticMethod ();
//stu.n=20;//Cannot assign a value to final variable 'n'
//Student.sn=200;//Cannot assign a value to final variable 'sn'
}
}

构造方法：

语法： 修饰符 类名(参数列表){ }

1： 每个类都存在一个隐式的空参数的构造方法；

2： 自己可以显示的创建构造方法，创建之后会覆盖隐式的构造方法；

3： 构造方法是创建对象时调用 new 类名()；

4:    自己给自己创建的构造方法加上参数 初始化对象；

PS :自己私有化构造方法，就会导致这个类不能在其他类中创建对象使用

单例模式：

一个类只能存在一个对象，那么这个类就不能随随便便创建对象了

实现单例模式的前提就是私有化构造方法

在本类中定义一个固定的对象，由static 修饰 ，这个对象就可以使用类名直接调用了 ,而

且也只能调用这个对象

这个类之外就不能再创建对象，只拥有自己类中创建的一个对象

static & final :

static 静态的 唯一

属性 ：这个属性属于类，在内存中只会创建一份，不管创建多少个对象，这个静态

的属性在内存中都只有一份

可以使用类名直接调用 ，所有的对象名也都可以调用，调用的是同一份

方法： 可以由类名直接调用 ，静态方法中不能使用这个类中对象属性

代码块： 静态代码块 只有在类加载使用时执行一次

final : 最终的 特性-不可变

类： 不能被继承 不能作为父类

属性： 常量： 初始化赋值之后不能改变值的

对象成员属性： 对象成员常量

静态属性变量： 静态常量

方法: 不能被子类重写

有例子如下：

public class King{
String name;
private King(String name){
this.name = name;
}
static King king1 = new King ("查理二世");
public void method1(){
System.out.println (name + "国王执行方法1");
}
public void method2(){
System.out.println ("国王执行方法2");
}
public void method3(){
System.out.println ("国王执行方法3");
}
}
class Main{
public static void main(String[] args){
// King king;//= new King ("查理二世");
King king = King.king1;
king.method1 ();
king.method2 ();
king.method3 ();
King king1 = King.king1;
King king2 = King.king1;
King king3 = King.king1;
king1.method1 ();
king1.method2 ();
king1.method3 ();
king2.method1 ();
king2.method2 ();
king2.method3 ();
king3.method1 ();
king3.method2 ();
king3.method3 ();
}
}