189 8069 5689

JavaSE——类和对象-创新互联

目录

我们提供的服务有：网站设计、成都网站设计、微信公众号开发、网站优化、网站认证、康巴什ssl等。为上千余家企事业单位解决了网站和推广的问题。提供周到的售前咨询和贴心的售后服务，是有科学管理、有技术的康巴什网站制作公司

一、万物皆对象    

二、类的定义方式以及对象的实例化

1.类的定义方式

2.对象的实例化

三、类中的成员变量和成员方法的使用 

1.static修饰成员变量 

2.static修饰成员方法 

四、对象的整个初始化过程

1. 初始化对象

2.构造方法

3.默认初始化  

4.就地初始化

五、封装特性

访问限定符 

六、代码块

1.普通代码块

2.构造代码块 

3.静态代码块 

七、内部类

1.成员内部类

1）普通内部类

2）静态内部类 

2.局部内部类

一、万物皆对象    

1. 在学习类和对象之前先了解一下面向对象的过程：

一图可解传统洗衣服都面向一个过程：拿水盆->倒水->放衣服->放洗衣粉->手搓->换水->放洗衣粉->手搓->拧干->晾衣服，少一个环节可能都不行

  2.那么接下来关于面向对象洗衣服： 

以面向对象方式来进行处理，就不关注洗衣服的过程，具体洗衣机是怎么来洗衣服，如何来甩干的，用户不用去关心，只需要将衣服放进洗衣机，导入洗衣粉，启动开关

二、类的定义方式以及对象的实例化

类是用来对一个实体(对象)，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)

1.类的定义方式
  • class为定义类的关键字，ClassName为类的名字，{}中为类的主体
// 创建类
class ClassName{ 
    field; // 字段(属性) 或者 成员变量
    method; // 行为 或者 成员方法 
}
  • 类中包含的内容称为类的成员，属性主要是用来描述类的，称之为类的成员属性或者类成员变量。方法主要说明类具有哪些功能，称为类的成员方法
public class WashMachine {
    public String brand;// 品牌
    public String type;// 型号
    public double weight;// 重量
    public double lenght;// 长
    public double weigth;// 宽
    public double height;// 高
    public String color;// 高

    public void washClothes(){// 洗衣服
        System.out.println("洗衣功能");
    }

    public void dryClothes(){// 脱水
        System.out.println("脱水功能");
    }

    public void setTime(){// 定时
        System.out.println("定时功能");
    }
}
  • 小练习巩固定义类：
public class PetDog {
    //定义一个狗类
    public String name;//名字
    public String color;//颜色

    // 狗的属性
    public void barks(){
        System.out.println(name+"：汪汪汪~~~");
    }

    // 狗的行为
    public void wag(){
        System.out.println(name+"：摇尾巴~~~");
    }
}

2.对象的实例化
  • 用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象
public class Main {
    //实例化
    public static void main(String[] args) {
        PetDog dogh = new PetDog();//通过new实例化对象
        dogh.name = "阿黄";
        dogh.color = "黑黄";
        dogh.barks();
        dogh.wag();

        PetDog dogs = new PetDog();
        dogh.name = "阿黄";
        dogh.color = "黑黄";
        dogh.barks();
        dogh.wag();
    }
}

  • this引用的是调用成员方法的对象
public class Date {
    public int year;
    public int month;
    public int day;

    public void setDay(int year,int month,int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
    public void printDate(){
        System.out.println(this.year+"/"+this.month+"/"+this.day);
    }

    public static void main(String[] args) {
        Date d = new Date();
        d.setDay(2023,1,12);
        d.printDate();
    }
}

【this引用的特性】

        1. this的类型：对应类类型引用，哪个对象调用就是哪个对象的引用类型         2. this只能在 " 成员方法 " 中使用         3. 在 " 成员方法 " 中， this 只能引用当前对象，不能再引用其他对象         4. this是 “ 成员方法 ” 第一个隐藏的参数，编译器会自动传递
三、类中的成员变量和成员方法的使用 

1.static修饰成员变量 
  • static修饰的成员变量，称为静态成员变量 
public class Student1{
    public String name;
    public String sex;
    public int age;
    public double score;
    public static String classRoom = "Bit306";

    public static void main(String[] args) {
        // 静态成员变量可以直接通过类名访问
        System.out.println(Student1.classRoom);

        Student1 s1 = new Student1("LiLeiLei","男",18,3.8);
        Student1 s2 = new Student1("HanMeiMei","女",19,4.0);
        Student1 s3 = new Student1("Jim","男",18,2.6);

        // 也可以通过对象访问：但是classRoom是三个对象共享的
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
        System.out.println(s3.classRoom);

    }
}

【静态成员变量特性】

        1. 不属于某个具体的对象，是类的属性，所有对象共享不存储在某个对象的空间中         2. 既可以通过对象访问，也可以通过类名访问         3. 类变量存储在方法区当中         4. 生命周期伴随类的一生 ( 随类的加载而创建，随类的卸载而销毁 )
2.static修饰成员方法 
  • Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问

public class Student2 {
    public String name;
    public String gender;
    public int age;
    public double score;
    public static String classRoom = "Bit306";

    public static String getClassRoom(){
        return classRoom;
    }

    public static void main(String[] args) {
        System.out.println(Student2.classRoom);
    }

}

【静态方法特性】

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

2. 可以通过对象调用，也可以通过类名.静态方法名(...)方式调用

3. 静态方法没有隐藏的this引用参数

4. 静态方法中不能调用任何非静态方法

四、对象的整个初始化过程 1. 初始化对象
  • ​​​​​​需要调用之前写的SetDate方法才可以将具体的日期设置到对象中

2.构造方法
  • 构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次
public class Date {
    public int year;
    public int month;
    public int day;

    // 构造方法：
    // 名字与类名相同，没有返回值类型，设置为void也不行
    // 一般情况下使用public修饰
    // 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
    public Date(int year,int month,int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
    public void printDate(){
        System.out.println(this.year+"/"+this.month+"/"+this.day);
    }

    public static void main(String[] args) {
        // 此处创建了一个Date类型的对象，并没有显式调用构造方法
        Date d = new Date(2023,1,12);// 输出Date(int,int,int)方法被调用了
        d.printDate();//2023/1/12
    }
}

【构造方法特性 】

        1. 名字必须与类名相同         2. 没有返回值类型，设置为 void 也不行         3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次         4. 构造方法可以重载 ( 用户根据自己的需求提供不同参数的构造方法 ) 
public class Date1 {
    public int year;
    public int month;
    public int day;

    //无参构造方法
    public Date1() {
        this.year = 2023;
        this.month = 1;
        this.day = 12;
    }

    //带有三个参数的构造方法
    public Date1(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public void printDate(){
        System.out.println(year+"-"+month+"-"+day);
    }

    public static void main(String[] args) {
        Date1 d = new Date1();
        d.printDate();
    }
}
  • 名字相同，参数列表不同构成了方法重载

 5. 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定无参

3.默认初始化  

public class Snakek {
    private int age;

    public static void main(String[] args) {
        Snakek snakek = new Snakek();
        System.out.println(snakek.age);//0
    }
}
  • 要搞清楚这个过程，就需要知道 new 关键字背后所发生的一些事情 

在程序层面只是简单的一条语句，在JVM层面需要做好多事情，下面简单了解：

        1. 检测对象对应的类是否加载了，如果没有加载则加载         2. 为对象分配内存空间         3. 处理并发安全问题         4. 初始化所分配的空间

4.就地初始化
  • 在声明成员变量时，就直接给出了初始值 
public class Date2 {
    public int year = 2023;
    public int month = 1;
    public int day = 12;

    public Date2() {

    }

    public Date2(int year, int month, int day) {

    }

    public static void main(String[] args) {
        Date2 d1 = new Date2(2023,1,12);
        Date2 d2 = new Date2();
    }
}
五、封装特性

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行 交互 

访问限定符 

public ：可以理解为一个人的外貌特征，谁都可以看得到 default: 对于自己家族中 ( 同一个包中 ) 不是什么秘密，对于其他人来说就是隐私了 private ：只有自己知道，其他人都不知道 
public class Computer {
    private String cpu;//cpu
    private String memory;//内存
    public String screen;//屏幕
    String brand;// 品牌---->default属性

    public Computer(String cpu, String memory, String screen, String brand) {
        this.cpu = cpu;
        this.memory = memory;
        this.screen = screen;
        this.brand = brand;
    }

    public void Boot(){
        System.out.println("开机~~~");
    }

    public void PowerOff(){
        System.out.println("关机~~~");
    }

    public void SurfInternet(){
        System.out.println("上网~~~");
    }

}

public class TestComputer {
    public static void main(String[] args) {
        Computer p = new Computer("HW","17","8G","13*14");
        System.out.println(p.brand);// default属性：只能被本包中类访问
        System.out.println(p.screen);// public属性： 可以任何其他类访问
        //System.out.println(p.cpu);// private属性：只能在Computer类中访问，不能被其他类访问
    }
}
  • 一般情况下成员变量设置为private，成员方法设置为public
六、代码块

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字可分为以下四种 ：普通代码块 、构造块 、静态块 、同步代码块（后续讲解多线程部分再谈）

1.普通代码块
  • 普通代码块：定义在方法中的代码块 
public class Main {
    public static void main(String[] args) {
        { //直接使用{}定义，普通方法块
            int x = 10;
            System.out.println("x1 = "+x);//x1 = 10
        }
        int x = 100;
        System.out.println("x2 = "+x);//x2 = 100
    }
}
2.构造代码块 
  • 构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量 
public class Student {
    //实例成员变量
    private String name;
    private String sex;
    private int age;
    private double score;

    public Student() {
        System.out.println("l am Student in it ()!");
    }

    //实例代码块
    {
        this.name = "bit";
        this.age = 12;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }

    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }
}

public class Main {
    public static void main(String[] args) {     
        Person p1 = new Person();
        p1.show(); 
    }
}
3.静态代码块 
  • 使用static定义的代码块称为静态代码块，一般用于初始化静态成员变量 
public class Student1 {
    private String name;
    private String gender;
    private int age;
    private double score;
    private static String classRoom;

    //实例化代码块
    {
        this.name = "bit";
        this.age = 12;
        this.gender = "man";
        System.out.println("I am instance init()!");
    }

    //静态代码块
    static {
        classRoom = "bit306";
        System.out.println("I am static init()!");
    }

    public Student1() {
        System.out.println("I am Student init()!");
    }

    public static void main(String[] args) {
        Student1 s1 = new Student1();
        Student1 s2 = new Student1();
    }
}

【注意事项】

  1.静态代码块不管生成多少个对象，其只会执行一次

  2.静态成员变量是类的属性

  3.如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次合并，最终放在生成的方法中，该方法在类加载时调用，并且只调用一次

  4.实例代码块只有在创建对象时才会执行

七、内部类
  • 在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现

1.成员内部类

在外部类中，内部类定义位置与外部类成员所处的位置相同 

1）普通内部类
  • 未被static修饰的成员内部类 
public class OutClass1 {
    private int a;
    static int b;
    int c;
    public void methodA(){
        a = 10;
        System.out.println(a);
    }

    public static void methodB(){
        System.out.println(b);
    }

    // 成员内部类：未被static修饰
    class InnerClass{
        int c;
        public void methodInner(){
            // 在内部类中可以直接访问外部类中：任意访问限定符修饰的成员
            a = 100;
            b = 200;
            methodA();
            methodB();
            // 如果外部类和内部类中具有相同名称成员时，优先访问的是内部类自己的
            c = 300;
            System.out.println(c);
            // 如果要访问外部类同名成员时候，必须：外部类名称.this.同名成员名字
            OutClass1.this.c = 400;
            System.out.println(c);
        }
    }

    public static void main(String[] args) {
        // 外部类：对象创建 以及 成员访问
        OutClass1 outClass1 = new OutClass1();
        System.out.println(outClass1.a);
        System.out.println(outClass1.b);
        System.out.println(outClass1.c);
        outClass1.methodA();
        outClass1.methodB();

        System.out.println("=============内部类的访问=============");
        
        // 创建内部类对象
        InnerClass innerClass = new OutClass1().new InnerClass();

        // 先将外部类对象先创建出来，然后再创建内部类对象
        InnerClass innerClass2 = outClass1.new InnerClass();
        innerClass2.methodInner();
    }
}
【 注意事项 】         1. 外部类中的任何成员都可以被在普通内部类方法中直接访问         2. 在内部类方法中访问同名的成员时，优先访问自己的         3. 普通内部类对象必须在先有外部类对象前提下才能创建         4. 外部类中，不能直接访问内部类中的成员，如果要访问必须先要创建外部类的对象
2）静态内部类 
  • 被static修饰的内部成员类称为静态内部类 
public class OutClass2 {
    private int a;
    static int b;
    public void methodA(){
        a = 10;
        System.out.println(a);
    }

    public static void methodB(){
        System.out.println(b);
    }

    // 静态内部类：被static修饰的成员内部类
    static class InnerClass{
        public void methodInner(){
            // 在内部类中只能访问外部类的静态成员
            //a = 100;  // 编译失败，因为a不是类成员变量
            b = 200;
            //methodA();    // 编译失败，因为methodB()不是类成员方法
            methodB();
        }
    }

    public static void main(String[] args) {
        // 静态内部类对象创建 & 成员访问
        InnerClass innerClass = new InnerClass();
        innerClass.methodInner();
    }
}
【 注意事项 】         1. 在内部类中只能访问外部类中的静态成员         2. 创建内部类对象时，不需要先创建外部类对象
2.局部内部类
  • 定义在外部类的方法体或者{}中 
public class OutClass3 {
    int a = 10;
    public void method(){
        int b = 10;

        // 局部内部类：定义在方法体内部
        // 不能被public、static等访问限定符修饰
        class InnerClass{
            public void methodInnerClass(){
                System.out.println(a);
                System.out.println(b);
            }
        }

        // 只能在该方法体内部使用，其他位置都不能用
        InnerClass innerClass = new InnerClass();
        innerClass.methodInnerClass();
    }

    public static void main(String[] args) {
        //OutClass2.InnerClass innerClass = null;编译失败
    }
}
【 注意事项 】         1. 局部内部类只能在所定义的方法体内部使用         2. 不能被 public 、 static 等修饰符修饰
与君共勉：时间最不偏私，给任何人都是二十四小时；时间也最偏私，给任何人都不是二十四小时

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧


当前标题：JavaSE——类和对象-创新互联
标题URL：http://jkwzsj.com/article/disiph.html

其他资讯