Java入门篇 之 补 类与对象

本篇碎碎念：每个人的想法都不一样，不要强求，顺其自然，要相信，一切都在向好的方面前进！！！！

今日份励志文案:山海的浩瀚，宇宙的浪漫，都在我内心翻腾，在推着我前进

冲冲冲！！！！

目录

前言：类与对象的的定义与使用

1.创建类

 2.创建具体的对象

一.封装 

二.访问限定符

 三.包

四.static成员

五.代码块

六.Math类（拓展）：

---

前言：类与对象的的定义与使用

1.创建类

class 类名{

   成员变量/实例对象；
   成员方法；

}

 2.创建具体的对象

类名称 引用名称=new 类名称();

例如：

class Student {
    public String name ;
    public int age;
    public String sex;
}
public class happy {
 
    public static void main(String[] args){
 
        Student people=new Student();
        people.age=20;
        people.name="ly";
        people.sex="女";
 
        System.out.println("年龄:"+people.age);
        System.out.println("姓名:"+people.name);
        System.out.println("性别:"+people.sex);
    }
}

一.封装 

面向对象的几个重要的特征：封装，继承，多态

封装：将类的实际细节进行了隐藏，对外只提供一些开放的接口

封装只不过是在类外看不见这个字段

给public变成private

public：是一个访问修饰限定符，可以修饰类名，接口，方法，成员变量

private：方法或成员属性被private修饰后，当前方法或成员变量只能在当前类中使用

直接拿不到的话，可以间接拿到，利用函数的方法去调用

class Student {
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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 static void main(String[] args) {
        Student student = new Student("张三",10);
        student.setName("小王");
        System.out.println(student.getName());
        System.out.println(student.getAge());
 }

get方法开头，后面跟着的属性名首字母大写的形式(上述代码中也有体现)

由于该属性是私有的，因此在类的外部无法直接访问该属性，必须通过get方法来获取属性的值

set方法，用于设置对象的私有属性值，跟get方法一样，后面跟着的属性名首字母大写的形式

并接受一个参数，即要设定的属性值

二.访问限定符

public：可以理解为一个人的外貌特征，谁都可以看到

default:对于自己家族中(同一个包)不是什么秘密，对于其他人就是隐私（default默认的，什么都不写的情况时的默认权限）

private:只有自己知道，其他人都不知道

 三.包

为了更好的管理类，把多个类收集在一起成为一组，成为软件包

如何在idea情况下建包：右键src，new，选择package，输入包名

用import导包

*表示通配，要哪一个就能匹配到哪一个

（更建议显示指定要导入的类名，否则容易出现冲突的情况）

四.static成员

被static修饰的成员变量不属于对象；也不依赖于对象；

就不能通过对象的引用来访问，不是报错是警告；可以这样做但是不合理

合理的方式是：通过类名访问，不属于对象，属于类

类的成员变量 其实有两种

(1) 静态成员变量

1静态成员变量类的，不属于对象的

2 类名+点号来访问静态成员变量

(2) 非静态成员变量/普通成员变量

1 属于对象的，每实例化一个对象，都会有一个对应的非静态成员变量；

2 每个对象都有,对应的引用+点号来访问

static修饰的成员变量，成为静态成员变量

静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的

静态成员变量特性：

1不属于某个具体的对象，是类的属性，是所有对象所共享的，不存储在某个对象的空间

2.既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问

3.类变量存储在方法区中

4.生命周期伴随类的一生(随类的加载而创建，随类的卸载而销毁)

Java没有全局变量的概念，静态的只能是成员变量，不能是局部变量

Static修饰成员方法：

成员变量是里面的内容（{   }里面的内容）

成员方法：

修饰符 返回类型 方法名 （参数列表）{方法体}

例如 public String student(String name){ ... }

静态方法特性:

1.不属于某个具体的对象，是类方法

2.可以通过对象调用，也可以通过类名.静态方法名（...）方式调用，更推荐后者

3.在静态方法内部不能使用非静态的数据成员

4.静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用

五.代码块

普通代码块，定义在方法当中的代代码块

被static修饰的代码块是静态代码块

先执行静态代码块，在执行实例代码块，最后是执行构造方法

同为静态代码块，看定义的顺序进行运行

怎么定义就怎么按照顺序运行

注意：静态代码块不管生成多少个对象，只会执行一次

class TestStatic {
    public static int staticNum = 100;
    public int data1 = 10;

    {
        //构造代码块 || 实例代码块
        System.out.println("实例代码块被执行了....");
        data1 = 1000;//一般情况下  用来初始化 非静态的数据成员
        //staticNum = 1000000;
    }

    static {
        System.out.println("静态代码块被执行了....");
        staticNum = 9999;
    }

    static {
        staticNum = 91999;
    }

    public TestStatic() {
        System.out.println("执行构造方法.....");
    }
}

public class exam {
    public static void main(String[] args){
            TestStatic testStatic = new TestStatic();
        }
    }

 

六.Math类（拓展）：

有一些数学运算的表达式比较复杂，Java中的java.lang.Math类以静态方法的形式提供了很多常用的数学函数，比如：指数、对数、三角函数和平方根等等。这些常用的数学函数能够使我们快速的得到一些复杂的数学运算结果，而不需要我们自己编写这些复杂的运算。

Math提供的属性或方法：

1.Math.PI:代表圆周率

2.Math.max(a,b):比较数值a和b中哪一个大，返回大的那个数值.

3.Math.min(a,b):比较数值a和b中哪一个小，返回小的那个数值.

4.Math.pow(a,b):求a的b次幂

5.Math.sqrt(a);求a的平方根

6.Math.random();此方法会返回一个[0,1)之间的随机小数

 public static void main(String[] args){
        int a=10;
        int b=20;
        int c=Math.max(a,b);

        System.out.println(c);
    }

c的值为20，

使用前要导包

import static java.lang.Math.*;

如果有解释的不对或者不清晰，如果可以从评论区指出，我一定会加以修改，万分感谢

希望对你们有所帮助