包、类、方法的定义

92 阅读 0 评论 61 点赞

我是靠谱客的博主眯眯眼发卡，最近开发中收集的这篇文章主要介绍包、类、方法的定义，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

package demo211122;
//package -- java包

//格式=package 全包名；
//全包名=从资源文件夹到文件的路径，路径分隔符是“.”
//作用=标志当前文件所在的完整的包（全包名）

//关键字=具有特定功能作用的标识符
//标识符

/**
* @author 69416 文档注释javadoc--对文件、成员、（核心代码） alt shift j
*/

//public--访问修饰符--公有的

public class TestA {
}

   // class类定义
   // 作用=定义了一个类（java类文件）
   // 格式规则=class 类名{类体}
   // public修饰的类名必须与文件名一致
   // ps:一个文件中有且只能有一个公有的类

// 标识符=包、文件、变量、方法
   // 命名规则
   // 1-以字母数字下划线美元符组成
   // 2-数字不能开头
   // 3-不可以使用关键字
   // ps：标识符是大小写敏感的（见名识意）

package demo211122;

import java.util.Scanner;
//import引入=在当前文件中使用其他包的文件时，除了java。lang包
//格式规则：import 全文件名
//全文件名=全包名.文件名
//import java.util.*;不推荐（不包括子包下的文件）

public class TestC {
// 格式化ctrl shift f
// alt ?
// 主方法--当前文件启动程序时的运行入口
public static void main(String[] args) {
System.out.println(11);// 控制台标准输出
System.out.println(2);
System.out.println(33);
// 控制台标准输入
Scanner sc = new Scanner(System.in);
String line = sc.nextLine();// 阻塞
System.out.println(line);
System.out.println(44);
}
}

package demo211122;

public class TestD {// 类体--语法规则
// 在类体中可以直接书写，定义（声明）相关的代码，主要如变量、方法定义

   // 变量的定义
   // 简单格式规则=变量类型变量名称[=变量值]；
   // 成员变量--可以在多个方法中使用
   // 执行顺序--先定义再使用

 int a1;
 int a2 = 2;
 boolean b1 = true;
 String s;
 TestD td;

// 方法的定义
   // 简单格式规则=返回类型方法名称（参数列表）[方法体]
   // void:返回空=表示方法执行结束后不返回结果

void f0() {
        System.out.println(a2);
        int a2 = 100;// 变量重名--遵循前置就近原则
        System.out.println(a2);
        int k = 0;// 局部变量--当前范围（方法）内使用
        System.out.println(k);// 默认值
        // void f090{}//方法中不可以直接定义方法
    }
    void f1() {
        System.out.println(555);
        // 方法调用-本质过程=执行所调用的方法中的代码
        // 执行结束后返回到调用位置继续执行
        // 简单方法调用格式规则：方法名称（参数列表）
        f0();
        int k = 9;
        f2(k);// 实际参数变量
        f3(k, "aa");
        int q = f4();
    }
    // 方法参数传递=实参 复值 形参
    void f2(int a) {// 形式参数变量 int a=k;
    }
    void f3(int a, String s) {
    }
    int f4() {
        int p = 10;
        return 100;
    }
}

package demo211122;

public class TestE {
    
    class AAA{
        
    }
    // public -- 访问修饰符--公有的
    // static -- 功能是修饰符--静态的
    // 简单规则=静态方法中可以直接使用静态成员，不可以直接使用非静态成员
    public static void main(String[] args) {
        class AAA{
            
        }
        
        System.out.println(a2);
        f2();
        // 使用方式
        // 简单的使用方式（）只能个在当前文件中的成员
        // 标准的使用方式
        System.out.println(TestE.a2);
        TestE.f2();
    }
    static int a2 = 10;
    static void f2() {
        // new=在内存中新开辟创建一块控制地址
        // new 构造方法（）；类的实例化过程=类 创建一个 对象
        TestE t1 = new TestE();
        System.out.println(t1.a1);
        t1.f1();
        System.out.println(t1.a2);
    }
    // 类中没有定义构造方法时可用默认无参的构造方法，否则只能使用已定义的构造方法
    // 构造方法=方法名称与类名相同+没有返回类型
//    TestE() {
//
//    }
    // 方法重载=在同一个文件中，方法名称相同，方法参数不同（个数/类型/顺序）
//    TestE(int a) {
//
//    }
    // 实例（非静态）成员（变量、方法）
    int a1 = 10;
    void f1() {
    }
    void f1(int a) {
    }
    void f1(String a) {
    }
    void f1(int a, String b) {
    }
    void f1(String b, int a) {
    }
}

// 定义成员+使用成员
// 成员=变量+方法
// 类名对象=new 构造方法();
// 标准格式
// 类名。静态成员()
// 对象。实例成员()

// 对象。静态成员--不推荐
// 类名。实例成员--不可以

package demo211122;

public class TestF {
    // 变量
    // 1-引用类型
    // 2-基本数据类型
    // （byte/short）赋值运算中赋的值如果是个常量会自动识别成所赋值的类型
    byte bt1 = 0;// 字节
    short s1 = 0;// 短整型
    int i1 = 0;// 整形
    long l1 = 0L;// 长整型--毫秒数
    float f1 = 0.0F;// 单精度浮点型
    // 浮点型数据变量本身是个近似值,只能用于比较大小，不能用于算数运算
    double d1 = 0.0;// 双精度浮点型
    boolean b1 = false;// 布尔型true/false
    String st1 = null;
    char c1 = ' ';// 字符类型-单引号中有且只有一个字符
    // 字母 文字 数字 符号 转义字符n t \ ' " u0061
    // 字面量/直接量/常量
    // false/true 不是关键字
    // 自动类型转换
    // 混合运算过程中=常量、整形、浮点型、字符型变量
    // 在不同类型的数据中，先转化为其中最高的同一类型，然后再进行运算
    // 规则=bytecharshort<int<long<float<double
    // 强制类型转换=高级->低级
    // 数据范围溢出或精度损失
    public static void main(String[] args) {
        // 进制 十 二 八 十六
        int i = 10;
        String s1 = Integer.toBinaryString(i);
//        byte b0 = 1;
//        Byte bi = new Byte("120");
//        Byte b2 = 120;
//        int k1=bi.intValue();//api
//        
//        TestF tf=new TestF();
//        int i2 = 'A' + 1;
//        System.out.println(i2);
//        byte b = (byte) 130;
//        System.out.println(b);
//        int i3 = (int) 23.5;
//        System.out.println(i3);
//        char c2 = 61;
//        System.out.println(c2);
    }
}

package demo211122;

public class TestG {
    // 字符串
    String s0 = null; // 没有对象的变量
    String s1 = "abc"; // 有对象的变量
    String s2 = new String("abc");// 有对象的变量
    // PS:区别:
    // 基本数据类型:保存在栈内存中的简单数据，即这种值完全保存在内存中的一个位置。如: int i=2;
    // 引用类型:保存在栈内存中的引用名指向保存在堆内存中的对象引用（地址），类似一个指针/地址。如: String s=new String("abc");
    public static void main(String[] args) {
        String s01 = "abc";
        System.out.println(s01.toString());
        String s02 = String.valueOf(10);
        System.out.println(s02);
        int len = s01.length();
        System.out.println(len);
        char c = s01.charAt(1);// index=索引，下标[0,length-1]
        System.out.println(c);
        System.out.println(s01.startsWith(s01));
        System.out.println(s01.endsWith(s01));
        char[] ss = s01.toCharArray();
        String s03 = "aaa,b,c,d";
        String[] ss0 = s03.split(",");
    }
}