java学习笔记---2

2022/1/5

25.API

1.是什么?
(Application Programming Interface):应用程序编程接口;
2.Java中的API:
指得是JDK中提供各种功能的Java类;
这些类是将底层的实现封装起来,我们不需要关心这些类是如何实现的,只需要学习如何使用这些类;

3.JDK：（Java Development Kit）是针对java程序员提供的程序开发工具包；

关于JDK的用途：
作为Java语言的SDK，普通用户并不需要安装JDK来运行Java程序，而只需要安装JRE（Java Runtime Environment /Java 运行时环境）。
而程序开发者必须安装JDK来编译、调试程序

JDK包含组件（常用）：

名称	组件	说明
javac	编译器	将后缀名为.java的源代码编译成.class的字节码
java	运行工具	运行.class的字节码
jar	打包工具	将相关的类文件打包成一个文件
jrunscript		命令脚本运行

26.String

1.输入一个字符串数据 (Scanner)

Scanner sc = new Scanner(System.in);
String a = sc.nextLine();

2.String的特点:
String在java.lang包下,所有使用时不需要导包;
String代表字符串,所有带双引号的都是String的对象;
虽然String的值是可变的,但他们可以被共享;

3.String的构造方法

方法名	说明
public String()	创建一个空白字符串对象,不含有任何内容
public String(char[] chs)	根据字符组的内容,创建字符串对象
public String() bys	根据字节数组的内容,来创建字符串对象
String s = “abs”	直接赋值的方法来创建字符串对象,内容就是abs

public class StringGouZao {
    public static void main(String[] args) {  //String的构造方法

        String s1 = new String();     //创建一个空白字符串对象,不含有任何内容;
        System.out.println("s1: "+s1);

        char[] chs = {'a','b','c'}; //字符数组
        String s2 = new String(chs);   //根据字符组的内容,来创建字符串对象
        System.out.println("s2: "+s2);

        byte[] bys = {97,98,99,100};   //对应的是ascll码 97='a'
        String s3 = new String(bys);
        System.out.println("s3: "+s3);  //根据字节组的内容,来创建字符串对象;

        String s4 = "minei";
        System.out.println("s4: "+s4);  //直接赋值创建字符串对象;
    }
}

4.String对象的特点:
1.提供方法创建的字符串对象(前三种),每次new都会申请一个内存空间,虽然内容相同但是地址值不同;
2.以""方式创建的字符串,只要字符串相同,无论在程序中出现几次,都只建立一个String对象.

//用"=="号比较
基本类型:比较的是数据值是否相同;
引用类型:比较的是地址值是否相同; (引用类)

若字符串是对象,想要比较他的内容是否相同,可以通过一个方法来实现-----equals();

5.例子:用户登录
//需求:已知用户名和密码,用程序实现用户登录,总共三次机会,给出相应的提示

import java.util.Scanner;

public class YongHuiDengLu {
    public static void main(String[] args) {
        String name = "zaolongjie";
        String key = "lj123456";

        String a, b;

        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            System.out.print("请输入用户名:");
            a = sc.nextLine();
            System.out.print("请输入密码:");
            b = sc.nextLine();
            if (a.equals(name) && b.equals(key)) {
                System.out.println("登录成功!!");
                break;
            } else {
                System.out.println("密码错误!");
            }

        }
    }
}

例子2:遍历字符串(charAt( ))
//需求:键盘录入一个字符串,使用程序实现在控制台遍历该字符串;

import java.util.Scanner;

public class BianLIString {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入一个字符串:");
        String s = sc.nextLine();

        for (int i = 0; i < s.length(); i++) {   //s.length输出字符串的长度;
            System.out.println(s.charAt(i)); //s.charAt(i):指定索引处的字符值;
        }
    }
}

例子3:统计字符次数
//需求:键盘输入一个字符串,统计该字符串大小写字符,数字字符的个数出现的次数;

import java.util.Scanner;

public class SumStringNum {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入,想输啥输啥:");
        String s = sc.nextLine();
        int d = 0, x = 0, n = 0; //大写,小写,数字;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) >= 'a' && s.charAt(i) <= 'z') {
                x++;
            } else if (s.charAt(i) >= 'A' && s.charAt(i) <= 'Z') {
                d++;
            }
            if (s.charAt(i) >= '0' && s.charAt(i) <= '9') {
                n++;
            }
        }
        System.out.println("这里边,大写字母的个数是:" + d);
        System.out.println("这里边,小写字母的个数是:" + x);
        System.out.println("这里边,数字的个数是:" + n);
          
        /*请输入,想输啥输啥:123456asdfghASDFGH.,
                这里边,大写字母的个数是:6
        这里边,小写字母的个数是:6
        这里边,数字的个数是:6
*/
    }
}

例子4:拼接字符串
//需求:定义一个方法,吧int类型的数据按照指定格式拼接成一个字符串返回,调用该方法并在控制台输出结果.

public class StringPinJie {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4};
        String s = pin(arr);
        System.out.println(s);
    }

    public static String pin(int[] arr) {
        String s = "[";

        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                s += arr[i];
            } else {
                s += arr[i];
                s += ",";
            }
        }
        s += "]";
        return s;
    }
}

升级版:(采用StringBuilder)

public class StringPinJie {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4};
        String s = pin(arr);
        System.out.println(s);
    }

    public static String pin(int[] arr) {
        //在方法中采用StringBuilder方法进行拼接,结果按String返回;
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i=0;i<arr.length;i++){
            if (i==arr.length-1){
                sb.append(arr[i]);
            }
            else {
                sb.append(arr[i]+",");
            }
        }
        sb.append("]");
        return sb.toString();
    }
}

例子5:字符串反转
//键盘输入一个字符串,输出该字符串的反转;

import java.util.Scanner;

public class StringReverse {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入,想输啥输啥:");
        String s = sc.nextLine();
        System.out.print("反转结果:" + fz(s));
    }

    public static String fz(String s) {
        String ss = "";
        for (int j = s.length() - 1; j >= 0; j--) {
            ss += s.charAt(j);
        }
        return ss;
    }
}
/*
请输入,想输啥输啥:fghjk
        反转结果:kjhgf
        Process finished with exit code 0
*/

升级版:

import java.util.Scanner;

public class StringReverse {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入,想输啥输啥:");
        String s = sc.nextLine();
        System.out.print("反转结果:" + fz(s));
    }

    public static String fz(String s) {
        //通过StringBuilder的reverse来对字符实现反转;
        StringBuilder sb = new StringBuilder(s);
        sb.reverse();
        return sb.toString();
    }
}

27.StringBuilder

1.背景: 如果对一个字符串进行拼接,每次拼接都会构建一个新的String对象,耗时又耗空间;

		String s = "nihao";  //占了3个空间
    	s +="java";
        System.out.print(s);

2.StringBuilder: 是一个可变字符串类,相当于一个容器;
//这里的可变是指:StringBuilder中的对象内容可变;

3.区别: String中的内容不可变,StringBuilder相反;

4.StringBuilder的构造方法:

方法名	说明
public StringBuilder()	创建一个空白字符串对象,不包含任何内容
public StringBuilder(String str)	根据字符串内容创建可变字符串对象

public class StringBuilderDemo {
    public static void main(String[] args) {
        StringBuilder s = new StringBuilder();   //创建空白
        System.out.println("s:"+s);

        StringBuilder ss = new StringBuilder("meini");  //根据字符串内容
        System.out.println("ss:"+ss);
    }
}

5.StringBuilder的添加和反转方法:
添加: public StringBuilder append(任意类型);
反转: public StringBuilder reverse();

public class StringBuilderDemo {
    public static void main(String[] args) {
        StringBuilder s = new StringBuilder();   //创建空白
        StringBuilder ss = s.append("jelly");

        s.append("fghsjk").append("dfghjk");  //链式编程
        System.out.println("s:"+s);  //添加数据返回数据本身
        System.out.println("ss:"+ss);
        System.out.println(s.reverse());
    }
}

/*      s:jellyfghsjkdfghjk
        ss:jellyfghsjkdfghjk
        kjhgfdkjshgfyllej
*/

6.String和StringBuilder的相互转换:

• String---->StringBuilder: public StringBuilder(String s):
• StringBuilder---->String: public String toString():

public class S_SB_ZhuanHuan {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("ninihaihai");

        String s = sb.toString();  //转换
        System.out.println(s);

        String sc = "hello";
        StringBuilder s2 = new StringBuilder(sc); //转换
        System.out.println(s2);
    }
}

2022/1/6

28.ArrayList

1.集合的背景: 编程时如果要存储多个数据,使用长度固定的数组存储格式,不一定满足我们的需求,更适应不了变化的需求.
2.集合: 提供一种存储空间可变的存储类型,存储的数据容量可以发生改变;
集合类有很多,其中一个—ArrayList;
3.ArrayList< E >:

• 可调整大小的数据实现;
• < E>:是一种特殊的数据类型,泛型;
• 在出现E的地方我们使用引用数据类型替换
• ArrayList< String>,ArrayList< Student>;

4.ArrayList构造方法和添加方法

方法名	说明
public ArrayList()	创建一个空的集合对象
public boolean add(E e)	将指定的元素追加到此集合的末尾
public void add(int index,E elemt)	在此集合的指定位置插入指定的元素

import java.util.ArrayList;

public class ArryListDemo {
    public static void main(String[] args) {
//        public ArrayList();  创建一个空的集合对象
        ArrayList<String> array = new ArrayList<String>();

//        public boolean add(E e); 将指定元素追加到此集合的末尾;返回的是是否添加成功
        System.out.println(array.add("hello!"));

        array.add("nihao!");  //在末尾添加
        array.add("jiefeng");

        array.add(1, "longjie!"); //在指定位置添加元素

        System.out.println("array: " + array); //输出集合
    }
}

5.ArrayList的常用方法:

方法名	说明
public boolean remove(Object o)	删除指定元素,返回删除是否成功
public E remove(int index)	删除指定索引处的元素,返回被删除元素
public E set(int index,E elem)	修改指定索引处的元素,返回被修改的元素
public E get(int index)	返回指定索引处的元素
public int size()	返回集合中的元素个数

import java.util.ArrayList;

public class ArryListDemo {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<String>(); //创建集合

        array.add("mieni");  //添加元素
        array.add("longjie");
        array.add("jianmian");
        array.add("hard");

        System.out.println(array);  //输出集合

        System.out.println(array.remove("hard"));  //删除集合中的hard 返回是否删除成功
        System.out.println(array.remove("happy")); //删除失败因为集合中没有"happy"
        System.out.println(array);  //输出集合

        System.out.println(array.remove(1)); //删除索引指定的元素 返回被删除的元素
        System.out.println(array);

        System.out.println(array.set(1,"yiqing")); //修该指定位置的元素内容,返回被修改的元素
        System.out.println(array);

        System.out.println(array.get(0)); //返回指定位置的元素 不修改集合
        System.out.println(array);

        System.out.println(array.size()); //输出集合中的个数

    }
}

6.例子1:存储字符串并遍历
//需求:创建一个存储字符串集合,存储个3字符串元素,使用程序实现在控制台遍历该集合;

import netscape.javascript.JSUtil;

import java.util.ArrayList;

public class ArrayListBianLi {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<String>();

        array.add("wo");
        array.add("xiang");
        array.add("huijia");

        for (int i = 0; i < array.size(); i++) {
            System.out.println(array.get(i));
        }
    }
}

例子2:存储学生对象并遍历
//需求:创建一个存储学生对象的集合,存储三个学生对象,使用程序实现在控制台遍历集合;

import java.util.ArrayList;

public class StudentJiHe {
    public static void main(String[] args) {

        //创建集合对象
        ArrayList<Student> s = new ArrayList<Student>();

        //创建学生对象
        Student s1 = new Student("zhaolongjie",22);
        Student s2 = new Student("xiaohu",21);

        s.add(s1);
        s.add(s2);

        for (int i = 0;i<s.size();i++){
            Student ss = s.get(i);
            System.out.println(ss.getAge()+ss.getName());
        }
    }
}

//需求:创建一个存储学生对象的集合,存储三个学生对象,使用程序实现遍历集合;学生的姓名和年龄来自键盘录入;

import java.util.ArrayList;
import java.util.Scanner;

public class StudentJiHe {
    public static void main(String[] args) {

        //创建集合对象
        ArrayList<Student> array = new ArrayList<Student>();

        for (int i = 0; i < 3; i++) {
            //键盘录入所需要的学生信息
            Scanner sc = new Scanner(System.in);
            System.out.print("请输入学生姓名: ");
            String name = sc.nextLine();
            System.out.print("请输入学生年龄: ");
            int age = sc.nextInt();

            //创建学生对象:
            Student s = new Student();
            s.setName(name);
            s.setAge(age);
            //将学生添加到集合当中
            array.add(s);

        }
        for (int i = 0;i<array.size();i++) {
            Student ss = array.get(i);
            System.out.println(ss.getAge() + ss.getName());
        }

    }
}

29.学生管理系统

需求:(139集)

分析:5个方法
思路:
1.定义学生类
2.主界面的代码编写
3.添加学生方法
4.删除学生
5.修改学生
6.查看所有学生
7.退出’

由于内容过大.代码及结果在另一篇文章:学生管理系统

30.继承

1.背景: 在两个类中,有很多相同内容,如果把它们之间相同的内容提取出来建立一个新的类,那么这个相同类和那两个类之间的关系就是继承;

2.继承: 是面向对象的三大特征之一;可以使得子类具有父类的属性和方法,还可以在子类中重新定义,追加属性和方法;
//在上述例子中,那个相同类就是父类, 其他两个类就是子类;

3.继承的格式:

• 格式: public class 子类名 extends 父类名{ }
• 范例:public class Zi extends Fu{ }
• //父类:也被称为基类,超类;
• //子类:也称为派生类;

public class Fu {  //这是一个父类
    public void show(){
        System.out.println("show方法被调用!");
    }
}

public class Zi extends Fu { //这是一个子类方法
    public void method(){
        System.out.println("method方法被调用!");
    }
}

public class Demo {  //测试类
    public static void main(String[] args) {
        //创建对象,调用方法
        Fu f = new Fu();
        f.show();
        Zi z  =new Zi();
        z.method();
        z.show(); //通过子方法调用父方法的内容
    }
}
/*  运算结果:
        show方法被调用!
        method方法被调用!
        show方法被调用!
*/

//说明:子类可以有父类的内容也可以有自己特有的内容!

4.继承的好处和弊端:

好处:

• 提高的代码的复用性;(多个类相同的成员可以放到通过一个类)
• 提高了代码的维护性;(如果方法的代码需要修改只修改一处就好)

弊端:

• 继承让类和类之间产生类关系,类的耦合性增强了,当父类发生变化的时候,削弱了子类的独立性;

什么时候使用继承?

• 继承体现的关系是:is a
• 假设法:如果现在有两个类A,B;如果它们之间满足:A是B的一种或者B是A的一种,这时候可以考虑继承,否则不能滥用;
• 比如:苹果和水果

笔记链接：java学习笔记三