分类 JAVA 下的文章

权限修饰符

什么是权限修饰符?

权限修饰符是用来限制类的成员(成员变量 成员方法 构造器...)能够被访问的范围

每一种权限修饰符能够被访问的范围如下

修饰符在本类中在同一个包下的其他类任意包下的子类任意包下的任意类里
私有方法private√
缺省缺省√√
受保护的protected√√√
公开的public√√√√
private < 缺省 < protected < public

super

访问父类成员

super.成员变量 //访问父类成员变量

super.成员方法 //调用父类成员方法

super() //调用父类的无参构造器

super(参数)//调用父类的有参构造器

this

访问本类成员

this.成员变量 //访问本类成员变量

this.成员方法 //访问本类的成员方法

this() //调用本类的空参构造器

this(参数) //调用本类的有参构造器

super与this注意事项

注意:this和super访问构造方法 只能用到构造器的第一句话否则会报错

包含父类属性的有参构造器

当子类继承父类且父类存在非私有属性, 子类的构造方法可以接收父类的属性

super的使用场景

当子类被创建出来时,想同时调用父类构造器时用super();

继承extends

子类可以继承父类的非私有成员(成员变量和成员方法)

继承后对象的创建是由子类和父类共同实现的

继承好处

提高代码复用性

继承的注意事项

Java 只支持单继承,无法多继承

但是可以多层继承

java的祖宗类Object 如果不显示的继承object java是默认继承的

JAVA String Api

//String 类在 java.lang 包下，所以使用的时候不需要导包
//equals方法
//判断是否相同 参数Object 可以代表所有的引入数据类型
//引入数据类型的对比

//trim方法
//删除首尾空格

//contains 方法
//判断一个字符串是否包含某个字符串
//返回 Boolean

//startsWith 方法
//判断是否是指定字符串开头
//返回 Boolean

//emdWith 方法
//判断是否是指定字符串结尾
//返回 Boolean

//toUpperCase 方法
//将字符串的英文全部转换成大写

//toLowerCase 方法
//将字符串的英文全部转换成小写


//charAt 方法
//获取索引位置的字符
//返回字符

//length 方法
//获取字符串的长度
//返回int

//toCharArray 方法
//将字符串转换成字符数组
//返回 char[]

//substring 方法
//截取字符串
//int index 的时候
//从index索引位置截取到末尾(包含开始)
//start end
//从start-end索引位置内容(包含开始,不包含结束)

//replace 方法
//替换指定字符串

// split 方法
// 分隔字符串
//获取当前时间戳
// System.currentTimeMillis()
//主要用来拼接字符串

static静态修饰符

static 静态
static修饰成员变量(静态成员变量)和成员方法(静态成员方法 )
成员变量一共分为静态(类)变量和实例变量
静态变量是要使用static修饰符 进行 修饰
由于静态变量是属于类的，只需要通过类名就可以调用：类名.静态变量
实例变量无法通过类名.变量名获取 
实例变量是属于对象的，需要通过对象才能调用：对象.实例变量

静态使用场景

静态经常用在工具类

生成验证码

/**
 * 生成验证码的工具类
 * @author TongHui
 * @date 2023.04.14 10:59
 */
public class CaptchaUtil {
    public static String getCaptcha(int length) {
        // 1、定义2个变量 一个是记住最终产生的随机验证码 一个是记住可能用到的全部字符
        String code = "";
        String data = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

        Random r = new Random();
        // 2、开始定义一个循环产生每位随机字符
        for (int i = 0; i < length; i++) {
            // 3、随机一个字符范围内的索引。
            int index = r.nextInt(data.length());
            // 4、根据索引去全部字符中提取该字符
            code += data.charAt(index); // code = code + 字符
        }
        return code;
    }
}
//使用方法 CaptchaUtil.getCaptcha(验证码长度)

static注意事项

  • 类方法中可以直接访问类的成员,不可以直接访问实例成员
  • 实例方法中既可以直接访问类成员,也可以直接访问实例成员
  • 实例方法可以出现this关键词,类方法中不可以使用this关键词

静态代码块

//静态代码块
//对象被加载的时候执行 静态代码块只会被执行一次
//无法访问实例方法和成员变量
static{

}

实例代码块

//实例代码块可以访问的实例成员

{
  可以直接访问实例成员
}

面向对象

package com.tonghui.day07;
public class Student {

    // 属性:用成员变量表示
    /**
     * 学生姓名
     */
    String name;
    /**
     * 年龄
     */
    int age;
    /**
     * 体重
     */
    double weight;
    /**
     * 性别
     */
    String sex;

    //行为:用成员方法表示(没有static关键的方法)

    /**
     * 行为: 学习方法
     */
    public void study(){
        System.out.println("好好学习");
    }
    /**
     * 行为: 打游戏
     * @param gameName 游戏名称
     */
    public void playGame(String gameName){
        System.out.println("喜欢打"+gameName);
    }
}

//不用
Student su = new Student();
su.name="张三";
//使用get和set对成员属性进行赋值和获取
/**
* 获取name值
*/
public String getName(){
    return name;
}
/**
* 设置name值
*/
public void getName(String name){
    this.name=name
}

//所有的成员变量都要加上private关键词
//作用:属性私有化,其他类访问不到成员变量,只能被本类访问
//public
//作用:成员行为公开,所有类都可以访问到
//Refrigerator.java
package com.tonghui.day07;

/**
 * @author TongHui
 * @date 2023.04.06 10:43
 */
public class Refrigerator{
    /**
     * 放进的物品
     */
    private String name;

    /**
     * 打开冰箱门
     */
    public void openDoor(){
        System.out.println("打开门");
    }
    /**
     * 把物品 放进冰箱
     */
    public void push(){
        System.out.println("把"+name+"放进冰箱");
    }
    /**
     * 关门
     */
    public void closeDoor(){
        System.out.println("关上冰箱门");
    }
    /**
     * 设置name
     * @param name 需要放进冰箱的物品
     */
    public void setName(String name) {
        this.name = name;
    }
}
//Test.java
package com.tonghui.day07;

/**
 * @author TongHui
 * @date 2023.04.06 10:41
 */
public class Test {
    public static void main(String[] args) {
        Refrigerator refrigerator = new Refrigerator();
        refrigerator.setName("大象");
        refrigerator.openDoor();
        refrigerator.push();
        refrigerator.closeDoor();
    }
}
//使用构造方法
//特点:
//类型和方法名相同
//没有返回值类型,连void都不能写

//调用格式
//new 类名(参数)

//每一个类都默认的一个无参构造器
//一旦写了有参的构造器 那么无参构造器就没了

//构造器与set方法给属性赋值的区别： 
//构造器只能给属性赋值一次(只适合于参数不多的情况)
//set方法可以多次

:::tips
一个类就是一个数据类型
:::

//1.定义位置
//成员变量:定义在类中方法外 作用于整个类
//局部变量:定义在方法内或方法生命上作用与方法里
//2.在内存中的位置
//成员变量在:堆内存中
//局部变量在:栈内存中
//3.生命周期
//成员变量:随着对象的创建而创建,随着对象的消失而消失
//局部变量:随着方法的调用而创建,随着方法的消失而消失
//4.初始化值
//成员变量有默认值
//局部变量没有默认值,必须赋值
//封装:
//就是将不想对外暴露的属性隐藏起来，对外提供一些方法供别人去操作，这样可以更安全，也可以提高代码的复用性
//this:
//可以用来区分局部变量和成员变量同名问题;
// this代表当前对象的引用 谁来调用这个方法 this就代表谁

//一个出租车 属性: 车牌 车型 所属公司
//行为: 载客 输出(尊敬的....乘客,....的车载您到了目的)
package com.tonghui.day07;

/**
 * 出租车的类
 * @author TongHui
 * @date 2023.04.06 16:18
 */
public class Taxi {
    /**
     * 车牌
     */
    private String id;
    /**
     * 所属公司
     */
    private String firm;
    /**
     * 车型
     */
    private String type;

    public Taxi() {
    }

    public Taxi(String id, String firm, String type) {
        this.id = id;
        this.firm = firm;
        this.type = type;
    }
    public void passenger(String name){
        System.out.println("尊敬的"+name+"乘客,"+firm+"的车载您到了目的");
    }
    /**
     * 获取
     * @return id
     */
    public String getId() {
        return id;
    }

    /**
     * 设置
     * @param id
     */
    public void setId(String id) {
        this.id = id;
    }

    /**
     * 获取
     * @return firm
     */
    public String getFirm() {
        return firm;
    }

    /**
     * 设置
     * @param firm
     */
    public void setFirm(String firm) {
        this.firm = firm;
    }

    /**
     * 获取
     * @return type
     */
    public String getType() {
        return type;
    }

    /**
     * 设置
     * @param type
     */
    public void setType(String type) {
        this.type = type;
    }
    @Override
    public String toString() {
        return "Taxicab{id = " + id + ", firm = " + firm + ", type = " + type + "}";
    }
}


Taxi taxi = new Taxi();
taxi.setId("浙A XXXXXXX");
taxi.setFirm("123");
taxi.setType("轿车");
taxi.passenger("TongHui");

Taxi taxi1=new Taxi("浙A XXXXXXX","1234","面包车");
taxi1.passenger("TongHui1");

方法的使用

//一段具有独立功能的代码块 调用后执行
//代码块 在一对大括号的多行代码
//定义位置 在类里面  与main方法平级
//格式:
// public static void 方法名() {  

     // 方法体

// }
//提高代码的复用性
//调用:方法名()
/**
 * 自定义一个方法 打印1-100的整数
 */
public class Test {
    public static void main(String[] args) {
        printNum();
    }

    /**
     * 打印1-100的整数
     */
    public static void printNum(){
        for (int i = 1; i <= 100; i++) {
            System.out.println(i);
        }
    }
}

// 格式（多个参数）： 
// public static void 方法名 (数据类型 变量名1,数据类型 变量名2 ，…… ) {
//     … … 
// }

// 范例（多个参数）： 
// public static void getMax( int number1,int number2 ) { 
//    … … 
//}

// 方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错
// 方法定义时，多个参数之间使用逗号(,)分隔
 //形参：全称形式参数，是指在定义方法时，所声明的参数
 //实参：全称实际参数，调用方法时，实际传入的参数
//方法调用时，形参和实参的数量和类型必须相匹配，否则将出现编译错误
//设计一个方法（print） 用于打印 n 到 m 之间所有的奇数
//需求：设计一个方法（getMax） 这个方法可以打印 任意 3个整数中的最大数
//需求：设计一个方法（printArrMax） 这个方法可以打印 一个int数组中的最大值
//需求：设计一个方法（printArrSum） 这个方法可以打印 一个int数组中各个元素的和
public static void main(String[] args) {
        print(10,30);
        getMax(10,30,20);
        int [] arr={20,30,40};
        printArrMax(arr);
        printArrSum(arr);
    }

    /**
     * 打印 n-m之间的所有奇数
     * @param n 任意数
     * @param m 任意数
     */
    public static void print(int n,int m){
        int temp;
        if (m<n){
            temp=m;
            m=n;
            n=temp;
        }
        for (int i=n;i<=m;i++){
            if (i%2==1){
                System.out.print(i);
            }
        }
    }

    /**
     * 打印任意三个整数最大值
     * @param a 任意数
     * @param b 任意数
     * @param c 任意数
     */
    public static void getMax(int a,int b,int c){
        int temp=a>b?a:b;
        temp=temp>c?temp:c;
        System.out.println("最大值:"+temp);
    }

    /**
     * 打印 数组中最大值
     * @param arr 数组
     */
    public static void printArrMax(int[] arr){
        int temp=0;
        for (int i = 0; i < arr.length; i++) {
            if (temp<=arr[i]){
                temp= arr[i];
            }
        }
    }

    /**
     * 打印个数组中各个元素的和
     * @param arr 数组
     */
    public static void printArrSum(int[] arr){
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            sum=sum+arr[i];
        }
    }
//定义一个方法 把任意字符数组拼接成一个字符串
/**
* 将字符数组拼接成一个字符串
* @param c 拼接的字符数组
*/
public static void toStrings(char[] c){
   String s="";
   for (int i = 0; i < c.length; i++) {
       s=s+c[i];
   }
   System.out.println(s);
}
//定义:
// 返回值 :就这件事情做完之后的结果
// 返回值类型: 这件事情做完后的结果的数据类型
// 方法名:这件事情的名字
// 参数:做这件事情需要的东西
// 参数类型  : 参数的数据类型  
// 参数名:就是给参数取的一个名字

//格式:
// public static  返回值类型  方法名(参数类型 参数名,参数类型2 参数名2,.....){
//     方法体;
//     return 返回值;
// }
// 例如：
// public static int getMax(int a,int b){
//    int max = a>b?a:b;
//    return max;
// }
//1.返回一个值
//2.终止方法的运行
//3.void的方法也可以写return,后面什么也不加
//4.return后面不能直接写代码
//5.switch中也可以搭配return,且具有break的作用
//6.一个方法呢可以有多个return,但是必须处在不同的作用域里面
//定义一个方法
//该方法可以给水果称重算钱
//方法名weight()
//第二个方法
//该方法可以转账 付钱
//在方法里面就写一条输出语句
//本次转账多少钱
public static void main(String[] args) {
    pay(weight(10.0,1.2));
}
/**
* 称重算钱
* @param weight 重量
* @param money 钱
* @return
*/
public static double weight(double weight,double money){
    return weight*money;
}
/***
* 转账
* @param money 需要转账的金额
*/
public static void pay(double money){
  System.out.println("本场转账"+money);
}
// 1.返回值
// 2.方法名
// 3.参数列表
//(第二要素+第三要素)(方法名+参数列表)
//同一个类中,方法名相同,参数列表不同的方法叫重载
//参数个数不同
//参数类型不同
//参数的多类型顺序不同

数组Array

一个可以存很多数据的容器

定义:

1.类型[] 变量名;
规范`写法`
例如 int[] array;
2.数据类型 变量名[] 注意:(不要使用)
例如 int array[];
//动态指定长度
//推荐使用
int[] ageArray=new int[4];
//数组索引
//0 1 2 3 4 5
//索引范围 0-（数组的长度-1）
int[] ageArray=new int[4];
//设置数组索引为0的值改为18
ageArray[0]=18;

String[] nameArray=new String[4];
nameArray[0]="张三";
nameArrayp[1]="李四";
//获取数组索引为1的内容
System.out.prinln(nameArray[0]);
//遍历修改数组内容
for(int i=0;i<ageArray.length;i++){
 ageArray[i]=10;
}
//遍历查询数组内容
for(int i=0;i<ageArray.length;i++){
     System.out.prin(ageArray[i])
}
//定义一个长度为5的数组
//使用键盘录入五个明星的名字
//再写一个遍历输出你录入的名字 在一行
import java.util.Scanner;
public class Test1 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String[] names=new String[5];
        System.out.println("请输入五个明星名字");
        for (int i = 0; i < names.length; i++) {
            names[i]= sc.next();
        }
        System.out.print("你输入的五个明星名字是:");
        for (int i = 0; i < names.length; i++) {
            System.out.print(names[i]+" ");
        }
    }
}
//数组索引越界
//报错提示: ArrayIndexOutOfBoundsException
int[] arr=new int[4]
System.out.println(arr[4])  
//动态初始化数组 有默认值
//整形数组默认是0
//浮点数组默认是0.0
//布尔数组默认是false
//字符数组默认是空格
//字符串数组默认是null
//所有引入型数组默认值都是null
//1.省略格式 推荐使用
//格式 类型[] 变量名={"a","b"};
//例如:
String[] arr={"春","夏","秋","冬"};
int[] arr1={1,2,3,4,5,6};
// 2.标准格式  不推荐使用
// 格式: 数据类型[] 数组名=new 数据类型[] {元素1,元素2,元素3}
//数组求和
//对数组求平均数
int[] arr1={1,2,3,4,5,6};
int sum=0;
for (int i = 0; i < arr1.length; i++) {
    sum=sum + arr1[i];
}
System.out.println("该数组的和是"+sum);
System.out.println("该数组的平均数是"+((float)sum/(float)arr1.length));
//生成10个范围在[67-324]之间的随机数
//把生成的随机数放进数组里面
//根据数组把奇数的和求出来 并输出

Random r=new Random();
int[] arr=new int[10];
int sum=0;
for (int i = 0; i < arr.length; i++) {
    arr[i]=r.nextInt(258)+67;
    if (arr[i]%2!=0){
      sum=sum+arr[i];
    }
}
System.out.println(sum);
//生成10个范围在[67-324]之间的随机数
//把生成的随机数放进数组里面
//求数组中最小值 并输出

Random r=new Random();
int[] arr=new int[10];
int min=324;
for (int i = 0; i < arr.length; i++) {
    arr[i]=r.nextInt(258)+67;
      if (min > arr[i]){
      min=arr[i];
   }
}
System.out.println("数组中最小值:"+min);
//堆内存包含方法(内存)区
//引入数据类型主要存在堆内存中
//例如:
//int[] arr={1,2,3};
//首先在栈内存生成int[] arr;
//然后再通过栈内存的内存地址到堆内存中引入(寻址)


//栈内存是内存区内最小的
//基本数据类型存在栈内存中
// 例如:
// int a=20;
// 栈内存中 int a=20;

//所有的自变量都存在都存在堆内存
//除String
//String s="你好";
//首先在栈内存生成 String s;
//然后再在堆内存的方法区生成内存(寻址) 内存地址:"你好"

//例如:
//int[] arr={1,2,3};
//int[] arr1=arr;
//将 arr的内存地址赋值arr1;
//如果arr的值变了 arr1也跟着变

循环语句

  • while 循环
  • do…while 循环
  • for 循环

while循环

while是最基本的循环，它的结构为：

while(布尔表达式){
    //循环内容
}

只要布尔表达式为 true，循环就会一直执行下去。

do…while 循环

对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。

do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

do {
       //代码语句
}while(布尔表达式);

注意： 布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。

for循环

虽然所有循环结构都可以用 while 或者 do...while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单。

for循环执行的次数是在执行前就确定的。语法格式如下：

for(初始化; 布尔表达式; 更新){
    //代码语句
}

关于 for 循环有以下几点说明：

  • 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
  • 然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
  • 执行一次循环后，更新循环控制变量。
  • 再次检测布尔表达式。循环执行上面的过程。

Java 增强 for 循环

Java5 引入了一种主要用于数组的增强型 for 循环。

Java 增强 for 循环语法格式如下:

for(声明语句 : 表达式){
    //代码句子
}

声明语句： 声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式： 表达式是要访问的数组名，或者是返回值为数组的方法。

break 关键字

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。

break 跳出最里层的循环，并且继续执行该循环下面的语句。

语法

break 的用法很简单，就是循环结构中的一条语句：

break;

continue 关键字

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

在 for 循环中，continue 语句使程序立即跳转到更新语句。

在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

语法

continue 就是循环体中一条简单的语句：

continue;
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5