Java基础

Java

Java基础

面向对象基础

构造方法

package com.itheima.constructor;

public class TestStudent {
    public static void main(String[] args) {
        Student student=new Student("张三",23);
        student.show();
    }

}

package com.itheima.constructor;

public class TestStudent {
    public static void main(String[] args) {
        Student student=new Student("张三",23);
        student.show();
    }

}

对于构造方法，系统会统一分配构造方法，如果不书写构造方法，即为系统统一分配无参构造方法。

如果有构造方法，那么系统将不会分配构造方法

对象内存图

1. 对于栈内存、堆内存、方法区三个储存单位，首先main方法进入方法区，进入栈内存，之后将类的基本信息存入方法区当中，之后在堆内存当中创建对象。String=NUll age=0，在堆内存当中将对象的变量储存，成员方法不会储存。调用内存的方法的时候，首先找到堆内存当中的成员方法的地址，之后根据地址找到字节码，进行入栈操作。

对于002对象，应当是使用第一个对象的字节码生成的。堆内存对象的地址指向都是同一个。

2. 两个引用指向同一对象的内存图

垃圾回收

• 注意：当堆内存中对象或数组通过任何方式都被找不到时，系统会将空间自动回收。

局部变量和成员变量

this内存原理

对于两个name的意义以及地址是不相同的，this.name应当是通过栈内存中的对象去找到堆内存中的变量，而name就仅仅是方法中的参数

封装

将代码封装到方法当中是对代码的一种封装

将变量封装到类当中，是对数据的一种封装。

API基础

String类

特点

• Java程序中所有的双引号字符串都是String类的对象
• 字符串不可变，他们的值在创建后不能被修改
• 虽然String的值是不可变的，但是他们可以被共享

        String s1="abc";
        String s2="ab";
        String s3=s2+"c";
        System.out.println(s3==s1);

结果为false

当字符串之间使用+号串联（拼接）的时候，系统底层会自动创建一个StringBuilder对象，然后再调用其append方法完成拼接

拼接后，再调用其toString方法转换成String类型。

s1="abc";
s2="a"+"b"+"c";
System.out.println(s1==s2);

结果为true

上述代码通过字符串常量优化机制进行优化。因此指向的都是字符串常量池

需求∶已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示需求:已知用户名和密码，请用程序实现模拟用户登录.总共给三次机会，登录之后，给出相应的提示

public static void main(String[] args) {
    String username="admin";
    String password="123456";
    Scanner scanner=new Scanner(System.in);
    for (int i = 0; i < 3; i++) {
        System.out.println("请输入用户名");
        String inputUsername=scanner.nextLine();
        System.out.println("请输入密码");
        String inputPassword=scanner.nextLine();
        if(username.equals(inputUsername)&&password.equals(inputPassword)){
            System.out.println("登录成功");
            break;
        }else{
            System.out.println("登录失败");
            System.out.println("你还剩余"+(2-i)+"次机会");
        }
    }
}

字符串的遍历

需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串

思路：

• 键盘录入1个字符串，用Scanner实现
• 遍历字符串，首先要能够获取到字符串中的每一个字符
  • public char charAt(int index):返回指定索引处的char值，字符串的索引也是从0开始的
• 遍历字符串，其次能够获取到字符串的长度
  • public int length():返回字符串的长度
  • 数组的长度：数组名.length
  • 字符串的长度：字符串对象.length()

 Scanner scanner=new Scanner(System.in);
    System.out.println("请输入：");
    String s=scanner.nextLine();
    for (char cl:s.toCharArray()
         ) {
        System.out.println(cl);
    }
    //或者
    for (int i = 0; i < s.length(); i++) {
        char c=s.charAt(i);
        System.out.println(c);
    }
}

对于字符串的遍历，本质都是将其拆分为char字符进行遍历，可以采用toCharArray函数拆分为char数组以及charAt等方式。

统计字符次数

package com.itheima.constructor;

import java.util.Scanner;

public class Test3 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入");
        String s=scanner.nextLine();
        int low=0,up = 0,digital=0;
        for (char a:s.toCharArray()
             ) {
            if (a<='Z'&&a>='A')
                up++;
            else if (a<='z'&&a>='a') {
                low++;
            } else if (a <= '9' && a >= 0) {
                digital++;
            }else {
                System.out.println("您为输入数字以及字母");
            }
        }
        System.out.println("小写字母有"+low+"大写字母有"+up+"数字有"+digital);
    }
}

截取字符串

substring(int beginIndex)
返回一个字符串，这个字符串的子串。

String substring(int beginIndex, int endIndex)
返回一个字符串，这个字符串的子串。

package com.itheima.constructor;

public class demo2Substring {
    public static void main(String[] args) {
        //substring 字符串截取
        String s="itheima";
        String a=s.substring(2);
        System.out.println(a);
    }
}

字符串类型

public class demo2Substring {
    public static void main(String[] args) {
        //substring 字符串截取
//        String s="itheima";
//        String a=s.substring(2);
//        System.out.println(a);
        //电话号码加密字符串截取
        System.out.println("请输入手机号");
        Scanner scanner=new Scanner(System.in);

        String s= scanner.nextLine();
        String s1=s.substring(0,3);
        String s2=s.substring(3,7);
        String s3=s.substring(7,11);
        System.out.println(s1+s2+s3);
        s2="****";
        System.out.println(s1+s2+s3);
    }
}

替换敏感词内容

String replace

需求:键盘录入一个字符串，如果字符串中包含(TMD)，则使用***替换

package com.itheima.constructor;

import java.util.Scanner;

public class replace {
    public static void main(String[] args) {
        System.out.println("请输入你想说的一段话");
        Scanner scanner=new Scanner(System.in);
        String s=scanner.nextLine();
        String a=s.replace("TMD","***");
        System.out.println(a);
    }
}

切割字符串

public String[] split(String regex, int limit)

limit用法:

1.如果 limit > 0,(从左到右)最多分割 n - 1 次,数组的长度将不会大于 n,结尾的空字符串不会丢弃

2.如果 limit < 0,匹配到多少次就分割多少次,而且数组可以是任何长度。结尾的空字符串不会丢弃

3.如果 limit = 0,匹配到多少次就分割多少次,数组可以是任何长度,并且结尾空字符串将被丢弃。

package com.itheima.constructor;

import com.itheima.domain.Student;

import java.util.Scanner;

public class Test7 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入学生信息");
        String result = scanner.nextLine();
        String[] info=result.split(",");
//        System.out.println(info.length);
        System.out.println(info[0]);
        System.out.println(info[1]);
        Student student=new Student(info[0],info[1]);
        System.out.println(student);
    }
}

String方法小结

• equal函数 比较字符串的内容，严格区分大小写

• equalsIgnoreCase 比较字符串的内容忽略大小写

• length

• charAt 返回指定索引处的char值

• toCharArray将字符串拆分为数组之后返回

StringBuilder

Stringbuilder是一个可变的字符串类，我们可以把它看成一个容器

• 作用提高编程效率

package com.itheima.stringBuilder;

public class Demo1StringBuilder {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        StringBuilder builder=new StringBuilder();
        for (int i = 0; i < 50000; i++) {
            builder.append(i);
        }
        long end = System.currentTimeMillis();
        System.out.println(end-start);
       // method();
//        System.out.println(s);
    }

    public static void method() {
        long l = System.currentTimeMillis();
        String s="";
        for (int i = 0; i <= 50000; i++) {
            s+= i;
        }
        long end=System.currentTimeMillis();
        System.out.println(((end-l)));
    }
}

StringBuilder常用的方法

append

返回值是自己本身

StringBuilder sb=new StringBuilder();
sb.append(123);
sb.append("abc");
sb.append(true);
String a="sfd";
a=a+true;
System.out.println(a);
System.out.println(sb);

StringBuilder stringBuilder=new StringBuilder();
StringBuilder stringBuilder1=stringBuilder.append("红色");
StringBuilder stringBuilder2=stringBuilder.append("绿色");
System.out.println(stringBuilder==stringBuilder1);
System.out.println(stringBuilder1==stringBuilder2);
System.out.println(stringBuilder2);

链式编程：如果一个方法返回的对象的类型，对象就可以继续向下调用方法

reverse()

toString()

StringBuilder提高效率的原理

对称字符串

package com.itheima.stringBuilder;

import java.util.Scanner;

public class symmetry {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入字符串");
        String s= scanner.nextLine();
        StringBuilder stringBuilder= new StringBuilder(s);
        StringBuilder s2=stringBuilder.reverse();
        if(stringBuilder.equals(s2)){
            System.out.println("是对称字符串");
        }
    }
}

面向对象

内部类

package com.itheima.test;

public class Test1Inner {
    public static void main(String[] args) {
        outer.inner inner= new outer().new inner();
        inner.show();
    }

}
class outer{
    class inner{
        int num=10;
        public void show(){
            System.out.println("Inner .. show");
        }
    }
}

内部类可以访问外部类的数据

内部类可以分为：成员内部类，局部内部类

私有成员内部类

package com.itheima.test;

public class Test1Inner {
    public static void main(String[] args) {
        outer outer= new outer();
        outer.method();
    }

}
class outer{
    private class inner{
        int num=10;
        public void show(){
            System.out.println("Inner .. show");
        }
    }
    public void method(){
        inner inner=new inner();
        inner.show();
    }
}

静态成员内部类，可以通过类名直接进行访问。

局部内部类

定义在方法当中的类

package com.itheima.test4;

public class Test4Innerclass {
    public static void main(String[] args) {
        Outer outer=new Outer();
        outer.method();
    }
}
class Outer{
    public void method(){

        class Inner{
           public void show(){
               System.out.println("abc");
           }
        }
        Inner inner=new Inner();
        inner.show();
    }
}

局部内部类是定义在方法当中的类，所以外界无法直接是哟个，需要在方法内部创建对象并且使用。

而且，局部内部类可以调用外部内部类所有的信息。

匿名内部类

匿名内部类本质上是一个特殊的局部内部类，定义在方法的内部

前提是存在一个接口或者类

匿名内部类的理解：将继承、实现，方法重写创建对象放在了一步进行

代码解释：实现了Inter接口的实现类对象

package com.itheima.test2;

public class Test2Innerclass {
    public static void main(String[] args) {
        new Inter(){
            @Override
            public void show() {
                System.out.println("dsfasdfa");
            }
        }.show();

    }
}
interface Inter{
    void show();
}
class InterImpl implements Inter{

    @Override
    public void show() {
        System.out.println("实现类中的方法");
    }
}

匿名内部类在开发中的使用

测试中使用的多

package com.itheima.test1;

public class TestSwimming {
    public static void main(String[] args) {
        goSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println("匿名内部类的应用");
            }
        });
    }
    public static void goSwimming(Swimming swimming){
        swimming.swim();
    }
}
interface Swimming{
    void swim();
}

Lambda表达式

理解：对匿名内部类进行了优化-------函数式编程

本质上有一些区别

面向对象思想，更多关注怎么做，谁来做。而函数式思想更多的关注做什么

函数式编程思想的概述

函数式思想尽量去忽略对象的复杂的语法：“强调做什么，而不是以什么形式去做”

lambda表达式的练习

lambda表达式的使用前提

• 有一个接口
• 有且仅有一个方法等着被实现

package com.itheima.test5;

public class Test5 {
    public static void main(String[] args) {
        useStringHandler((String s)->{
            System.out.println(s);
        });
    }
    public static void useStringHandler(StringHandler stringHandler){
        stringHandler.printMessage("itheima");
    }
}
interface StringHandler{
    abstract void printMessage(String s);
}

Lambda表达式带参形式

package com.itheima.test7;

public class CalculatorDemo {
    public static void main(String[] args) {
        useCalculator(new Calculator() {
            @Override
            public int calc(int num1, int num2) {
                return num1+num2;
            }
        });
        useCalculator((int num1,int num2)->{
            return num1+num2;
        });
    }
    public static void useCalculator(Calculator calculator){
        System.out.println(calculator.calc(2,3));
    }
}
interface Calculator{
    int calc(int num1,int num2);
}

Lambda的省略格式

省略规则：

• 参数类型可以省略，但是如果有多个参数的情况下，不能仅仅省略一个
• 如果参数有且仅有一个，那么小括号可以省略
• 如果代码块的语句只有一条的情况下，可以省略大括号和分号，甚至是return

public static void main(String[] args) {
    useInter((a,b)->{
        return a+b;
    });
    useInter((double a,double b)->{
        return a+b;
    });
    useInter((a,b)->
        a+b 
    );
}

Lambda表达式和匿名内部类的区别

所需类型不同

• 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
• lambda表达式：只能是接口

使用限制不同：

• 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
• 如果接口中多于一个抽象方法,只能使用匿名内部类，而不能使用Lambda表达式

实现原理不同：

• 匿名内部类：编译之后，产生一个单独.class字节码文件
• Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

}

##### Lambda的省略格式

省略规则：

- 参数类型可以省略，但是如果有多个参数的情况下，不能仅仅省略一个
- 如果参数有且仅有一个，那么小括号可以省略
- 如果代码块的语句只有一条的情况下，可以省略大括号和分号，甚至是return

```java
public static void main(String[] args) {
    useInter((a,b)->{
        return a+b;
    });
    useInter((double a,double b)->{
        return a+b;
    });
    useInter((a,b)->
        a+b 
    );
}

Lambda表达式和匿名内部类的区别

所需类型不同

• 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
• lambda表达式：只能是接口

使用限制不同：

• 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
• 如果接口中多于一个抽象方法,只能使用匿名内部类，而不能使用Lambda表达式

实现原理不同：

• 匿名内部类：编译之后，产生一个单独.class字节码文件
• Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成