JAVA学习第五天

最新推荐文章于 2024-09-14 18:46:05 发布

“Z”

最新推荐文章于 2024-09-14 18:46:05 发布

阅读量409

点赞数

文章标签： java

本文链接：https://blog.csdn.net/Hdbvdvdge/article/details/123783734

版权

String

概述

String类定义的变量可以用于指向字符串对象，然后操作该字符串

String 其实被称为不可变字符串类型，他的对象在创建后不能被更改

创建方式

字符串比较

使用equals方法比较

equals方法是内容进行比较

import com.sun.org.apache.xerces.internal.impl.xpath.XPath;

import java.util.Scanner;

public class Application {
    public static void main(String[] args) {
        String uName = "zhengjiaming";
        String uPassword = "123456";

        // 返回字符串的长度
        System.out.println(uName.length());
        //获取某个索引位置的字符
        System.out.println(uName.charAt(0));
        // 使用新值将字符串中的旧值替换
        String newName = uName.replace("zhengjiaming", "xxx");
        // 把字符串分割成数组返回、
        String mX = "z,l,w,x";
        String[] xMX = mX.split(",");
        for (int i = 0; i < xMX.length; i++) {
            System.out.println(xMX[i]);
        }

        System.out.println(newName);
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String name = scanner.nextLine();
        System.out.println("请输入密码：");
        String password = scanner.nextLine();
        if (name.equals(newName) && password.equals(uPassword)){
            System.out.println("登录成功");
        }else {
            System.out.println("用户名或密码错误！！");
        }
    }

ArrayList

特点：大小不固定，可以进行动态变化，适合做增删改的业务场景

package ArrayList;

import java.util.ArrayList;

public class ArrayListDemo1 {
    public static void main(String[] args) {
        // 创建ArrayList集合的对象
        ArrayList list = new ArrayList();
        // 添加数据
        list.add("java");
        list.add("mysql");
        list.add("php");
        System.out.println(list.add(1));
        System.out.println(list);
        // 给指定索引位置插入数据
        list.add(1,"python");
        System.out.println(list);
    }
}

ArrayList<E>:其实就是一个泛型类，可以在编译阶段约束集合对象只能操作某种数据类型

ArrayList<String> 只能操作字符串

ArrayList<Integer> 只能操作整数类型的元素

package ArrayList;

import java.util.ArrayList;

public class ArrayListDemo02 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("java");
        list.add(4);

        ArrayList<String> list1 = new ArrayList<String>();  // 灰色string可以不写
        list1.add("sd");
        ArrayList<Integer> list2 = new ArrayList<>();  //只能存储整数
        list2.add(56);

    }
}

ArrayList常用API

package ArrayList;

import java.util.ArrayList;

public class ArrayListDemo02 {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<String>();  // 灰色string可以不写
        list1.add("java");
        list1.add("python");
        list1.add("c++");
        list1.add("php");

        System.out.println(list1);
        // 获取某个索引位置的元素值
        System.out.println(list1.get(0));
        // 元素的个数
        System.out.println(list1.size());
        // 完成集合的遍历
        for (int i = 0; i < 4; i++) {
            System.out.println(list1.get(i));
        }
        //删除某个索引位置的元素，并且把删除的元素返回
        System.out.println(list1);
        String a = list1.remove(0);
        System.out.println(list1);
        System.out.println(a);
        // 直接删除元素 成功true
        System.out.println(list1.remove("php"));
        System.out.println(list1);
        // 修改某个索引的值
        String l = list1.set(1,"c");
        System.out.println(l);
        System.out.println(list1);
    }
}

static 关键字的作用

static 静态的意思可以修饰成员变量和成员方法表示在内存中只存储一份可以被共享访问修改

package com.itzjm.statsic_d1;

public class User {
    // 在线人数信息 静态成员变量
    public static int onLineNumber; // 属于类只加载一次可以共享访问

    // 实例成员变量
    private String name;  // 属于对象
    private int age;

    public static void main(String[] args) {
        // 类名.静态成员变量
        User.onLineNumber++; // 上线一个人
        // 在同一个类中访问静态成员变量，类名可以省略
        System.out.println(onLineNumber);

        // 创建对象
        User u1 = new User();
         // 对象.实例成员变量
        u1.name = "sd";
        System.out.println(u1.name);
    }
}

static 修饰方法: 有static修饰，建议用类名访问，也可以用对象访问。 -- 属于类

package com.itzjm.static_d2;

public class Student {
    private String name;
    private int age;
    // 实例方法 没有static修饰 属于对象的行为可以访问对象的成员变量
    public void student(){
        System.out.println(name + "在学习");
    }
    
    //静态方法 有static 属于了可以被类和对象共享访问
    public static void getMax(int a,int b){
        System.out.println(a>b?a:b);
    }
    public static void main(String[] args) {
        // 实例方法的调用      
        Student s = new Student();
        s.name = "sd";
        s.student();
        
        // 静态方法的调用
        Student.getMax(5,6);
        //同一个类中类名可以省略
        getMax(88,99);

    }
}

使用场景：

表示对象自己的行为的，且方法中需要访问实例成员的，则该方法必须申明成实例方法

如果该方法是以执行一个功能为目的，则可以声明成静态方法。

static的注意事项

静态方法只能访问静态的成员，不可以直接访问实例成员

实例方法可以访问静态的成员，也可以访问实例成员

静态方法中是不可以出现this关键字的。

package com.itjiaming.d1_dom4j.zhuangshimoshi_d2;

public class Test {
    // 静态成员变量
    public static int onlineNumber = 0;
    public static void test2(){
        System.out.println("test2");
    }
    // 实例成员
    private String name;
    private void run(){
        System.out.println(name + "跑的块");
    }

        // 理解static访问相关的语法
    public static void main(String[] args) {

    }

        // 静态方法只能访问静态成员不能直接访问实例成员
    // 静态方法
    public static void test(){
        System.out.println(Test.onlineNumber);
        System.out.println(onlineNumber);
        test2();
        Test.test2();
//        System.out.println(name);// 报错不能直接访问实例成员
        Test t = new Test();
        t.name = "张三";
        t.run();
    }

    // 实例方法可以访问静态成员 也可以访问实例成员
    public void go(){
        System.out.println(onlineNumber);
        System.out.println(Test.onlineNumber);
        test2();

        System.out.println(name);
        run();
    }

    // 静态方法中不可以使用this
    /*
    this代表当前对象 static代表类  this不能代表类
     */


}

工具类

类中都是一些静态的方法，每个方法都是可以完成一个共用的功能为目的，这个类用来给系统开发人员共同使用。

package com.itjiaming.d1_dom4j.zhuangshimoshi_d2;

import java.util.Random;

public class Login {
    public static void main(String[] args) {
//        // 开发验证码
//        String data = "qwertyuioplkjhgfdaszxcvbnm123654789QWERTYUIOPALSKDJFHGZXVCBNM";
//        String code = "";
//        Random r = new Random();
//        for (int i = 0; i < 5; i++) {
//            int index = r.nextInt(data.length());
//            code += data.charAt(index);
//        }
//        System.out.println(code);
        System.out.println(Util.createVerifyCode(5));
    }
}

// 工具类 静态的方法
class Util{
    public static String createVerifyCode(int n){
        // 开发验证码
        String data = "qwertyuioplkjhgfdaszxcvbnm123654789QWERTYUIOPALSKDJFHGZXVCBNM";
        String code = "";
        Random r = new Random();
        for (int i = 0; i < n; i++) {
            int index = r.nextInt(data.length());
            code += data.charAt(index);
        }
        return code;
    }
}

工具类不用实例方法的原因

实例方法需要创建对象，浪费内存。

工具类定义时的要求：私有构造器


// 工具类 静态的方法
class Util{
    // 私有构造器不能创建对象
    private Util(){

    }
    public static String createVerifyCode(int n){
        // 开发验证码
        String data = "qwertyuioplkjhgfdaszxcvbnm123654789QWERTYUIOPALSKDJFHGZXVCBNM";
        String code = "";
        Random r = new Random();
        for (int i = 0; i < n; i++) {
            int index = r.nextInt(data.length());
            code += data.charAt(index);
        }
        return code;
    }
}

package test;
// 完成数组工具类的设计
public class ArrayUtil {
    // 私有构造器不能创建对象
    private ArrayUtil(){}

    // 静态的工具方法
    public static String toString(int[] arr){
        // 校验
        if (arr == null){
            return null;
        }
        // 拼接内容并返回 arr = []
        String result = "[";
        for (int i = 0; i < arr.length; i++) {
            result += (i == arr.length-1 ? arr[i] : arr[i] + ",");
        }
        result += "]";
        return result;
    }
}
package test;

public class Test {
    public static void main(String[] args) {
        int[] arr = null;
        int[] arr1 = {};
        int[] arr2 = {12, 23, 55, 99, 66};
        System.out.println(ArrayUtil.toString(arr));
        System.out.println(ArrayUtil.toString(arr1));
        System.out.println(ArrayUtil.toString(arr2));

    }
}

代码块

代码块概述：

代码块时类的五大成分之一(成员变量,构造器,方法,代码块,内部类)，定义在类中的方法外。
java类下，使用{} 括起来的代码被称为代码块。

代码块分为：

静态代码块：

格式： static{}

特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发，只执行一次

使用场景：在类加载的时候做一些静态数据初始化的操作，以便后续使用。

package com.itjiaming.d1_dom4j.test2;

import java.util.ArrayList;

public class StaticDemo {
    public static String schoolName;
    public static ArrayList<String> cards = new ArrayList<>();
        // 静态代码块 优先自动执行
    // 作用：用于初始化静态资源
    static {
            System.out.println("---------静态代码块执行了----------");
            schoolName = "哈理工";
            cards.add("2");
            cards.add("3");
        }
    public static void main(String[] args) {
        System.out.println(StaticDemo.schoolName);
    }
}

什么是设计模式

开发中经常遇到一些问题，一个问题通常有n种解法，但其中肯定有一种最优解，这个最优解就是设计模式。

设计模式解决什么问题
遇到这种问题，该模式应该怎么写，他是如何解决的

单例模式

可以保证系统中，应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象

单例的实现方式：饿汉单例设计模式

在用类获取对象的时候，对象提前为你创建好了

设计步骤：定义一个类，把构造器私有定义一个静态变量存储一个对象

package com.itjiaming.d1_dom4j.test3;
// 使用饿汉单例实现单例类
public class SingleInstance {
    //  把构造器私有
    private SingleInstance(){ }
    // 饿汉单例实在获取对象前提前准备好了一个
    public static SingleInstance instance = new SingleInstance();
}

class Test{
    // 饿汉单例的设计
    public static void main(String[] args) {
        SingleInstance s1 = SingleInstance.instance;
        SingleInstance s2 = SingleInstance.instance;
        System.out.println(s1 == s2); // true
    }
}

懒汉单例模式：

在真正需要该对象的时候，才去创建一个对象(延迟加载对象)

设计步骤：定义一个类，把构造器私有定义一个静态变量存储一个对象提供一个返回单例对象的方法

package com.itjiaming.d1_dom4j;

public class SingInstance {
    //构造器私有
    private SingInstance(){}
    //定义一个静态的成员变量负责存储一个对象  最好私有化
    private static SingInstance instance;
    // 定义方法 对外返回单例对象
    public static SingInstance getInstance(){
        if (instance == null){
            // 第一次来拿 需要创建对象
            instance = new SingInstance();
        }
        return instance;
    }

}
class Tets{
    public static void main(String[] args) {
        // 掌握懒汉单例的设计，理解其思想
        SingInstance s1 = SingInstance.getInstance();
        SingInstance s2 = SingInstance.getInstance();
        System.out.println(s1 == s2);  // true
    }
}

饿汉单例快懒汉不用就不创建节省内存

继承

继承是列与类之间的关系

子类继承父类继承：extends

提高代码的服用

提高代码的复用性减少代码的荣誉增强类的功能扩展性

子类 extends 父类

子类可以继承父类的属性和行为但是不能继承父类的构造器

java 是单继承模式一个类只能继承一个直接父类

java不支持多继承但是支持多层继承

java中所有的类都是Object类的子类

package com.itzjm.extends_d2;

public class ExtendsDemo {
    public static void main(String[] args) {
    Student student = new Student();
        //System.out.println(student.age);
        //student.run();
        // 子类可以调用父类的静态成员
        Student.inAdder();
        student.sleep();
        student.go();
    }
}
class People{
    private int age = 21;
    private void run(){
        System.out.println("人会跑");
    }
    public static int omLine = 161;
    public static void inAdder(){
        System.out.println("我们在快乐的学习java");
    }
    public void sleep(){
        System.out.println("人会睡觉");
    }
}
class Student extends People{
    public void sleep(){
        System.out.println("学生会睡觉");
    }
    public void go(){
        // 中转方法 先访问父类
        super.sleep();  // 父类的sleep()方法
    }
}

方法重写：子类和父类出现一样的方法声明，称子类的方法是重写的方法

package com.itzjm.extends_fangfachongxie;

public class Phone {
    public void call(){
        System.out.println("打电话");
    }
    public void sendMessage(){
        System.out.println("发短信");
    }
}
package com.itzjm.extends_fangfachongxie;

public class NewPhone extends Phone {
    //方法重写
    @Override // 方法重写注解  覆盖
    public void call(){
        super.call();
        System.out.println("可以视频通话");
    }
    @Override
    public void sendMessage(){
        super.sendMessage();
        System.out.println("支持发送图片和视频");
    }
}
package com.itzjm.extends_fangfachongxie;

public class PhoneTest {
    public static void main(String[] args) {
        NewPhone np = new NewPhone();
        np.call();
        np.sendMessage();
    }
}

注意：私有方法不能重写

package com.itzjm.extends_gouzaoqi;

public class Test{
    public static void main(String[] args) {
        Student student = new Student("xx",44,"ss");
        System.out.println(student.getName());
        System.out.println(student.getClassName());
        System.out.println(student.getAge());
    }
}
class People {
    private String name;
    private int age;

    public People(){

    }
    public People(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;
    }
}
class Student extends People{
    private String className;

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public Student(){
    }
    public Student(String name, int age, String className) {
        super(name, age);
        this.className = className;
    }
}

this与super

this代表本类对象的引用；super代表父类存储空间的标识

包

相同包下的类可以直接访问，不同包下的类必须导包才可以使用导包格式 import包名.类名;

package com.itzjm.package_d1;

import com.itzjm.package_d2.Animal;
import com.itzjm.package_d2.Cat;

public class Test {
    public static void main(String[] args) {
        // 导包 相同包下的类可以直接访问
        Student student = new Student();
        // 不同包下的类必须导包才可以使用
        Animal animal = new Animal();
        // 使用默认包内的类
        Cat cat1 = new Cat();
        // 当类名相同时 使用包名.类名的方法new 对象
        com.itzjm.package_d3.Cat cat2 = new com.itzjm.package_d3.Cat();
    }
}

权限修饰符

权限修饰符从小到大：private --> 缺省 --> protected --> public

private: 只能在同一个类中访问

package com.itzjm.package_d2.itcast;

public class Fu {
//    private: 只能在同一个类中访问
    private void show1(){
        System.out.println("private");
    }
//    缺省：同一个类中 同一个包中的其他类
    void show2(){
        System.out.println("缺省");
    }
//    protected:同一类中 同一个包中的其他类 不同包下的子类
    protected void show3(){
        System.out.println("protected");
    }
//    public：都可访问
    public void show4(){
        System.out.println("public");
    }

    public static void main(String[] args) {
        Fu fu = new Fu();
        fu.show1();
        fu.show2();
        fu.show3();
        fu.show4();
    }
}

缺省：同一个类中同一个包中的其他类

package com.itzjm.package_d2.itcast;

public class Demo {
    public static void main(String[] args) {
        Fu fu = new Fu();
        // private 私有的智能在同一个类中访问
    //    fu.show1();
        fu.show2();
        fu.show3();
        fu.show4();

    }
}

protected:同一类中同一个包中的其他类不同包下的子类

package com.itzjm.package_d2.ittheima;
import com.itzjm.package_d2.itcast.Fu;
public class Zi extends Fu {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.show3();
        zi.show4();
    }
}

public：都可访问

final

final :最终的意思可以修饰方法变量类

修饰方法表示该方法不能被重写

package com.itzjm.final_d1;
// final 语法只是
public class Test {
    public static void main(String[] args) {
        // 修饰方法 方法不能被重写
     Cat cat = new Cat();
     cat.run();
    }
}
class Animal{
    public final void run(){
        System.out.println("动物会跑");
    }
}
class Cat extends Animal{
    @Override
    public void run() { // 会报错
        super.run();
        System.out.println("老虎跑的快");
    }
}

修饰变量表示仅能被赋一次值

修饰类表示该类是最终类不能被继承

package com.itzjm.final_d1;
// final 语法只是
public class Test {
    public static void main(String[] args) {
        // 修饰类

    }
}
final class Animal{

}
class Cat extends Animal{  // 报错
}

抽象类

父类只定义该功能的基本要求具体实现有子类完成抽象类其实就是一种不完全的设计图

表示方法抽象类必须使用abstract修饰

修饰符 abstract class 类名{}

抽象方法：

就是抽象类中定义的子类必须完成成功的功能的基本要求

就是就是没有方法题只有方法签名必须abstract修饰

格式：修饰符 abstracr 返回值类型方法名称(形参列表);

package com.itzjm.abstract_d1;

public abstract class Animal {
    public abstract void run();
}
package com.itzjm.abstract_d1;

public class Dog extends Animal {
    @Override
    public void run() {
        System.out.println("狗跑的也很快");
    }
}
package com.itzjm.abstract_d1;

public class Tiger extends Animal {
    @Override
    public void run() {
        System.out.println("老虎跑的快");
    }
}
package com.itzjm.abstract_d1;

public class Test {
    public static void main(String[] args) {
        Tiger t = new Tiger();
        t.run();
        Dog dog = new Dog();
        dog.run();
    }
}

注意：抽象类用来继承抽象方法是交给子类重写实现的

一个类如果继承了抽象类那么这个类碧玺重写完成抽象类的全部抽象方法否则这个类也必须定义成抽象类

package abstract_d2;

// 抽象类的父类
public abstract class Card {
    private String name;
    private double money;

    // 抽象方法 支付功能 子类的支付功能不一样
    public abstract void pay(double money);

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

package abstract_d2;

public class GoldCard extends Card{
    // 金卡支付方法
    @Override
    public void pay(double money) {
        // 优惠后的支付金额
        double rs = money * 0.8;
        double lastMoney = getMoney() - rs;

        System.out.println(getName()+"当前账户总金额："+
                getMoney()+"当前消费了"+rs+"消费后余额："+
                lastMoney);
        setMoney(lastMoney);//更新账户余额
    }
}
package abstract_d2;

public class Test {
    public static void main(String[] args) {
        GoldCard gdldCard = new GoldCard();
        gdldCard.setMoney(10000);// 父类的
        gdldCard.setName("郑佳明");
        gdldCard.pay(300);
        System.out.println("当前余额"+ gdldCard.getMoney());
    }
}

package com.itzjm.abstract_d3;

public class Test {
    public static void main(String[] args) {
        // 抽象类得到了抽象方法 失去了创建对象的能力
        // 原因 不能实例化
        // Animal animal = new Animal(); // 报错
        // 一个类继承了抽象类 必须重写玩抽象类的全部抽象方法
        // 不能用abstract修饰变量 代码块 构造器

    }
}

abstract class Animal{
    public abstract void run();
}

class Cat extends Animal{
    @Override
    public void run() {

    }
}

final 和 abstract 是互斥关系

final ：修饰类表示该类是最终类不能被继承修饰方法表示该方法不能被重写

接口

接口就是具体规范的其中用抽象方法定义的一组行为规范接口是更加彻底的抽象

接口的格式：

Public interface 接口名{

常量

抽象方法

}

接口不能实例化

使用public修饰规范的目的就是公开化

package com.itzjm.interface_d1;

public interface SportManInterface {
    // JDK1.8之前 只有常量和抽象方法
    // public static final 可以省略
    public static final String SCHOOL_NAME = "黑马";
    // 抽象方法
    public abstract void run();
    public abstract void eat();
    
}
class Test{
    public static void main(String[] args) {
        // 接口不能创建对象
       // SportManInterface sportManInterface = new SportManInterface(); // 报错 
    }
}

接口的用法：

接口是用来被类实现（implements）的,实现接口的类被称为实现类实现类可以理解成所谓的子类

修饰符 class 实现类 implements 接口1,接口2,.....{

}

实现关键字 implements

package com.itzjm.interface_implements_d1;

public interface SportMan {
    public void run();
    public void bisai();

}

interface Law{
    public void rule();
}

// 实现类
class PingPongMan implements SportMan, Law{
    private String name;

    public PingPongMan(String name) {
        this.name = name;
    }

    // 重写接口的方法
    @Override
    public void run() {
        System.out.println("运动员要跑步");
    }

    @Override
    public void bisai() {
        System.out.println("运动员要比赛");
    }

    @Override
    public void rule() {
        System.out.println("遵章守法");
    }
}
// 测试类
class Test{
    public static void main(String[] args) {
        PingPongMan p = new PingPongMan("郑佳明");
        p.run();
        p.bisai();
        p.rule();

    }
}

类要实现接口必须重写接口的全部抽象方法否则这个类要定义成抽象类

类与接口是多实现

接口与接口可以实现多继承：规范合并整合多个接口为同一个接口便于子类的实现

package com.itzjm.interface_extends_d1;

public interface People {
    void eat();
}
interface Law{
    void guize();
    void eat();
}
interface SportMan extends Law, People{
    void run();
}
// 实现类
class BasketballMan implements SportMan {

    @Override
    public void eat() {

    }

    @Override
    public void guize() {

    }

    @Override
    public void run() {

    }
}

JDK8 以后新增了许多方法

允许接口中直接定义带有方法体的方法

第一种默认方法必须用default修饰需要用接口的实现类的对象来调

default void run(){

方法体;

}

第二种静态方法必须用static修饰接口的静态方法必须用本身的接口名来调用

static void inAddr(){

方法体;

}

第三种私有方法必须使用private修饰从JDK1.9才开始只能在本类中背其他的默认方法或者私有方法访问

private void go(){

方法体;

}

package com.itzjm.interface_jdk8_d1;

public interface SportManInter {
    // 默认方法(实例)  必须使用 defaut 修饰 默认使用 public修饰
    // 调用 接口不能创建对象 这个方法只能过继给实现类 由实现类的对象调用
    public default void run() {
       // go();
        System.out.println("跑的很快====");
    }
    // 静态方法 必须使用 Static 修饰 默认使用 public 修饰
    // 调用 接口名自己调用
    static void eat(){
        System.out.println("吃的很多====");
    }
    // 私有方法 JDK.9开始才有 必须在接口内部才能使用
//    private void go(){
//        System.out.println("出去====");
//    }

}

class PingPongMan implements SportManInter{

}
class Test{
    public static void main(String[] args) {
        PingPongMan p = new PingPongMan();
        p.run();
        SportManInter.eat();
    }
}

注意：接口不能创建对象一个类实现多个接口多个接口中的同样静态方法不冲突