基础技术笔记

面向对象三大特征

1.封装：

一、封装

1、封装的概念

封装性是面向对象编程的核心思想

指的就是将描述某种实体的数据和基于这些数的操作集合到一起，形成一个封装体

封装的思想保证了类内部数据结构的完整性，使用户无法轻易直接操作类的内部数据，这样降低了对内部数据的影响，提高了程序的安全性和可维护性。

2、封装的好处

只能通过规定方法访问数据
　　隐藏类数实现细节
　　方便修改实现
　　方便加入控制语句

3、封装的使用

1）、修改属性的可见性 ——> 设为private

2）、创建共有的 getter / setter方法 ——> 用于属性的读写

3）、在getter / setter方法中加入属性控制语句 ——> 对属性值的合法性进行判断

4、This关键字

this关键字主要有三个应用：

this调用本类中的属性，也就是类中的成员变量；
　　this调用本类中的其他方法；
　　this调用本类中的其他构造方法，调用时要放在构造方法的首行。

2.继承

：

1.概念：

继承是Java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或类从父 类继承方法，使得子类具有父类相同的行为。

2.特点：

继承鼓励类的重用
　　继承可以多层继承
　　一个类只能继承一个父类
　　父类中private修饰的不能被继承
　　构造方法不能被继承

3.总结super关键字：

super关键字；爱访问父类的成员

1.super只能出现在子类的方法和构造方法中；

2.super调用构造方法时，只能是第一句；

3.super不能访问法父类的private成员；

3.多态：

1.概念：

程序中的多态 ：父类引用，子类对象

同一种事物，由于条件不同，产生的结果也不同

多态：同一个引用类型，使用不同的实例而执行不同操作

将父类对象应用于子类对象的特征就是面向对象编程中的多态性的体现

多态指的就是在应用程序中出现的“ 重名 ” 现象。多态性允许以统一的风格编写程序，以处理种类繁多的已存在的类及其相关类。这样既降低了维护难度，又节省了时间

2、使用多态实现思路

编写父类

编写子类，子类重写父类方法

运行时，使用父类的类型，子类的对象

3、实现多态的三个必要条件

继承
　　重写
　　父类引用指向子类对象

0.数据类型

0.1八大基本数据类型取值

1.编码

A:65 a:97 48:0

2.运算符（+,-,*./,%,++,–）

package one3_operator;
/+,-,./,%,++,–
*

• /
  public class operator {
  public static void main(String[] args) {
  int a=10;
  int b=20;
  int c=40;
  System.out.println(a+b);//30
  System.out.println(a-b);//-10
  System.out.println(ab);//200
  System.out.println(a/b);//0 取商
  System.out.println(a%b);//10 取余

  }
  }

2.1.+号用法

package plus_sign;

public class Jplus _sign {
public static void main(String[] args) {
String s1=“hello”;
String s2=“world”;
System.out.println(s1);//hello
System.out.println(s1+s2);//helloworld
System.out.println(20+s1);//20hello

}

}

2.2.++,–

package one5_lizenglijian;

public class Li_Zeng_Li_Jian {
public static void main(String[] args) {
int num1 = 10;
System.out.println(num1); // 10
++num1; // 单独使用，前++
System.out.println(num1); // 11
num1++; // 单独使用，后++
System.out.println(num1); // 12
System.out.println("=================");

    // 与打印操作混合的时候
    int num2 = 20;
    // 混合使用，先++，变量立刻马上变成21，然后打印结果21
    System.out.println(++num2); // 21
    System.out.println(num2); // 21
    System.out.println("=================");

    int num3 = 30;
    // 混合使用，后++，首先使用变量本来的30，然后再让变量+1得到31
    System.out.println(num3++); // 30
    System.out.println(num3); // 31
    System.out.println("=================");

    int num4 = 40;
    // 和赋值操作混合
    int result1 = --num4; // 混合使用，前--，变量立刻马上-1变成39，然后将结果39交给result1变量
    System.out.println(result1); // 39
    System.out.println(num4); // 39
    System.out.println("=================");

    int num5 = 50;
    // 混合使用，后--，首先把本来的数字50交给result2，然后我自己再-1变成49
    int result2 = num5--;
    System.out.println(result2); // 50
    System.out.println(num5); // 49
    System.out.println("=================");

    int x = 10;
    int y = 20;
    // 11 + 20 = 31
    int result3 = ++x + y--;
    System.out.println(result3); // 31
    System.out.println(x); // 11
    System.out.println(y); // 19

    // 30++; // 错误写法！常量不可以使用++或者--
}
}

2.3.赋值

/*
赋值运算符分为：

基本赋值运算符：就是一个等号“=”，代表将右侧的数据交给左侧的变量。
int a = 30;

复合赋值运算符：
+= a += 3 相当于 a = a + 3
-= b -= 4 相当于 b = b - 4
*= c *= 5 相当于 c = c * 5
/= d /= 6 相当于 d = d / 6
%= e %= 7 相当于 e = e % 7

注意事项：
1. 只有变量才能使用赋值运算符，常量不能进行赋值。
2. 复合赋值运算符其中隐含了一个强制类型转换。
*/

2.4标题

/*
比较运算符：
大于： >
小于： <
大于等于： >=
小于等于： <=
相等： == 【两个等号连写才是相等，一个等号代表的是赋值】
不相等： !=

注意事项：

1. 比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false
2. 如果进行多次判断，不能连着写。
   数学当中的写法，例如：1 < x < 3
   程序当中【不允许】这种写法。
   */

2.5.&&，||，！，

/*
与（并且） && 全都是true，才是true；否则就是false
或（或者） || 至少一个是true，就是true；全都是false，才是false
非（取反） ! 本来是true，变成false；本来是false，变成true

与“&&”，或“||”，具有短路效果：如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，从而节省一定的性能。

注意事项：

1. 逻辑运算符只能用于boolean值。
2. 与、或需要左右各自有一个boolean值，但是取反只要有唯一的一个boolean值即可。
3. 与、或两种运算符，如果有多个条件，可以连续写。
   两个条件：条件A && 条件B
   多个条件：条件A && 条件B && 条件C

TIPS：
对于1 < x < 3的情况，应该拆成两个部分，然后使用与运算符连接起来：
int x = 2;
1 < x && x < 3
*/
public class Shuang {
public static void main(String[] args) {
System.out.println(true && false); // false
// true && true --> true
System.out.println(3 < 4 && 10 > 5); // true
System.out.println("============");

    System.out.println(true || false); // true
    System.out.println(true || true); // true
    System.out.println(false || false); // false
    System.out.println("============");

    System.out.println(true); // true
    System.out.println(!true); // false
    System.out.println("============");

    int a = 10;
    // false && ...
    System.out.println(3 > 4 && ++a < 100); // false
    System.out.println(a); // 10
    System.out.println("============");

    int b = 20;
    // true || ...
    System.out.println(3 < 4 || ++b < 100); // true
    System.out.println(b); // 20
}

}

2.6.三元运算符

/*
一元运算符：只需要一个数据就可以进行操作的运算符。例如：取反!、自增++、自减–
二元运算符：需要两个数据才可以进行操作的运算符。例如：加法+、赋值=
三元运算符：需要三个数据才可以进行操作的运算符。

格式：
数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B;

流程：
首先判断条件是否成立：
如果成立为true，那么将表达式A的值赋值给左侧的变量；
如果不成立为false，那么将表达式B的值赋值给左侧的变量；
二者选其一。

注意事项：

1. 必须同时保证表达式A和表达式B都符合左侧数据类型的要求。

2. 三元运算符的结果必须被使用。
   */
   public class SanYuanYunSuanFu {
   public static void main(String[] args) {
   int a = 10;
   int b = 20;

    // 数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B;
    // 判断a > b是否成立，如果成立将a的值赋值给max；如果不成立将b的值赋值给max。二者选其一
    int max = a > b ? a : b; // 最大值的变量
    System.out.println("最大值：" + max); // 20
   
    // int result = 3 > 4 ? 2.5 : 10; // 错误写法！
   
    System.out.println(a > b ? a : b); // 正确写法！
   
    // a > b ? a : b; // 错误写法！
   

   }
   }

3.方法

/*
定义一个方法的格式：
public static void 方法名称() {
方法体
}

方法名称的命名规则和变量一样，使用小驼峰。
方法体：也就是大括号当中可以包含任意条语句。

注意事项：

1. 方法定义的先后顺序无所谓。
2. 方法的定义不能产生嵌套包含关系。
3. 方法定义好了之后，不会执行的。如果要想执行，一定要进行方法的【调用】。

如何调用方法，格式：

方法名称();
*/

4.流程控制语句

4.1.break

package one8_break;
/*
break关键字的用法有常见的两种：

    1. 可以用在switch语句当中，一旦执行，整个switch语句立刻结束。
    2. 还可以用在循环语句当中，一旦执行，整个循环语句立刻结束。打断循环。

    关于循环的选择，有一个小建议：
    凡是次数确定的场景多用for循环；否则多用while循环。
    */

public class Break {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
// 如果希望从第4次开始，后续全都不要了，就要打断循环
if (i == 4) { // 如果当前是第4次
break; // 那么就打断整个循环
}
System.out.println(“Hello” + i);
}
}
}

4.2.continue

package one9_continue;
/*
另一种循环控制语句是continue关键字。
一旦执行，立刻跳过当前次循环剩余内容，马上开始下一次循环。
*/
public class Continue {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i == 4) { // 如果当前是第4层
continue; // 那么跳过当前次循环，马上开始下一次（第5层）
}
System.out.println(i + “层到了。”);
}
}
}

4.3双重for

package one11_shuang_chong_for;

public class ShuangChongFor {
public static void main(String[] args) {
for (int hour = 0; hour < 24; hour++) { // 外层控制小时

        for (int minute = 0; minute < 60; minute++) { // 内层控制小时之内的分钟
            System.out.println(hour + "点" + minute + "分");
        }

    }
}

}

4.4重载和重写

对于功能类似的方法来说，因为参数列表不一样，却需要记住那么多不同的方法名称，太麻烦。

方法的重载（Overload）：多个方法的名称一样，但是参数列表不一样。
好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能。

方法重载与下列因素相关：

1. 参数个数不同
2. 参数类型不同
3. 参数的多类型顺序不同

方法重载与下列因素无关：

1. 与参数的名称无关

2. 与方法的返回值类型无关
   */
   public class Chong_Zai {

   public static void main(String[] args) {
   /System.out.println(sumTwo(10, 20)); // 30
   System.out.println(sumThree(10, 20, 30)); // 60
   System.out.println(sumFour(10, 20, 30, 40)); // 100/

    System.out.println(sum(10, 20)); // 两个参数的方法
    System.out.println(sum(10, 20, 30)); // 三个参数的方法
    System.out.println(sum(10, 20, 30, 40)); // 四个参数的方法
   

// System.out.println(sum(10, 20, 30, 40, 50)); // 找不到任何方法来匹配，所以错误！

    sum(10, 20);
}

public static int sum(int a, double b) {
    return (int) (a + b);
}

public static int sum(double a, int b) {
    return (int) (a + b);
}

public static int sum(int a, int b) {
    System.out.println("有2个参数的方法执行！");
    return a + b;
}

// 错误写法！与方法的返回值类型无关

// public static double sum(int a, int b) {
// return a + b + 0.0;
// }

// 错误写法！与参数的名称无关

// public static int sum(int x, int y) {
// return x + y;
// }

public static int sum(double a, double b) {
    return (int) (a + b);
}

public static int sum(int a, int b, int c) {
    System.out.println("有3个参数的方法执行！");
    return a + b + c;
}

public static int sum(int a, int b, int c, int d) {
    System.out.println("有4个参数的方法执行！");
    return a + b + c + d;
}

}

4.5增强for

package one14_zeng_qiang_for;
/*

• for(元素数据类型 变量：数组或者Collection集合){使用变量即可}
• */
  import java.util.ArrayList;
  import java.util.List;

public class ZengQiangFor {
public static void main(String[] args) {
// TODO Auto-generated method stub

    // 增强for遍历集合
    List<String> list = new ArrayList<String>();
    list.add("哈哈哈哈");
    list.add("呜呜呜呜");
    list.add("嘿嘿嘿嘿嘿");
    list.add("嘻嘻");
    for (String string : list) {
        System.out.println(string);
    }

    // 增强for遍历数组
    int[] arr = { 21, 4, 2, 53, 645, 43, 64, 21, 45 };
    for (int num : arr) {
        System.out.print(num + " ");
    }

}

5.反转

5.1方法一

package one5_fan_zhuan;

public class fanzhuan1 {
public static void main(String[] args) {
int[] array = { 10, 20, 30, 40, 50 };

    // 遍历打印数组本来的样子
    for (int i = 0; i < array.length; i++) {
        System.out.print(array[i]);
    }
    System.out.println("============");

    /*
    初始化语句：int min = 0, max = array.length - 1
    条件判断：min < max
    步进表达式：min++, max--
    循环体：用第三个变量倒手
     */
    for (int min = 0, max = array.length - 1; min < max; min++, max--) {
        int temp = array[min];
        array[min] = array[max];
        array[max] = temp;
    }

    // 再次打印遍历输出数组后来的样子
    for (int i = 0; i < array.length; i++) {
        System.out.print(array[i]);
    }
}

}

5.2方法二

StringBuffer sb =new StringBuffer(“abcd”);
System.out.println(sb.reverse().toString());
输出结果：dcba；
备注：此方法针对的是io流，不能bai针对字符串。

StringBuffer sb=new StringBuffer(“abcdefg”);
StringBuffer sb2=sb.reverse();
System.out.println(“对StringBuffer进行反转操作后为:”+sb2);
}

5.3冒泡

package bulubulu;

public class Maopao {
private static int [] a={12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
static int temp=0;//一个临时存放点
public static void main(String[] args) {
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a.length; j++) {
if(a[j]>a[i]){//相邻的两个数依次进行比较,如果先改变正序或反序，可以改变大小于
temp=a[j];
a[j]=a[i];//在三行进行一个值的移动替换
a[i]=temp;
}
}
}
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}
}
冒泡排序与选择排序

5.31从小到大

package one5_fan_zhuan;

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

    int []array={10,11,13,14,17};
    for(int i=0;i<(array.length-1);i++)
    {
        for(int j=i+1;j<array.length;j++)
        {
            if(array[i]>array[j])
            {
                int zhong=array[i];
                array[i]=array[j];
                array[j]=zhong;
            }
        }
    }
    System.out.println("从下到大："+array[0]+" "+array[1]+" "+array[2]+" "+array[3]+" "+array[4]);
}

}

5.32从大到小

public static void main(String[] args) {

    int []array={10,11,13,14,17};
    for(int i=0;i<array.length;i++)
    {
        for(int j=i+1;j<array.length;j++)
        {
            if(array[i]<array[j])
            {
                int temp=array[i];
                array[i]=array[j];
                array[j]=temp;
            }
        }
    }
    for (int i=0;i<array.length;i++){
        System.out.println(""+array[i]+"");
    }
}

}

5.33.字符串中的所有字符升序排列，并倒序打印

/*
题目：
请使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印。
*/
public class Dao_Xu_Pai_Xu {
public static void main(String[] args) {
String str = “asv76agfqwdfvasdfvjh”;

    // 如何进行升序排列：sort
    // 必须是一个数组，才能用Arrays.sort方法
    // String --> 数组，用toCharArray
    char[] chars = str.toCharArray();
    Arrays.sort(chars); // 对字符数组进行升序排列

    // 需要倒序遍历
    for (int i = chars.length - 1; i >= 0; i--) {
        System.out.println(chars[i]);
    }
}

}

6.ArrayList当中的常用方法有：

/*
ArrayList当中的常用方法有：

6.1public boolean add(E e)：向集合当中添加元素，参数的类型和泛型一致。返回值代表添加是否成功。

备注：对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。
但是对于其他集合（今后学习）来说，add添加动作不一定成功。
ArrayList list = new ArrayList<>();
System.out.println(list); // []

    // 向集合中添加元素：add
    boolean success = list.add("柳岩");
    System.out.println(list); // [柳岩]
    System.out.println("添加的动作是否成功：" + success); // true

    list.add("高圆圆");
    list.add("赵又廷");
    list.add("李小璐");
    list.add("贾乃亮");
    System.out.println(list); // [柳岩, 高圆圆, 赵又廷, 李小璐, 贾乃亮]

6.2public E get(int index)：从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。

// 从集合中获取元素：get。索引值从0开始
String name = list.get(2);
System.out.println(“第2号索引位置：” + name); // 赵又廷
public E remove(int index)：从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素。

6.3从集合中删除元素：remove。索引值从0开始。

    String whoRemoved = list.remove(3);
    System.out.println("被删除的人是：" + whoRemoved); // 李小璐
    System.out.println(list); // [柳岩, 高圆圆, 赵又廷, 贾乃亮]

6.4public int size()：获取集合的尺寸长度，返回值是集合中包含的元素个数。

    // 获取集合的长度尺寸，也就是其中元素的个数
    int size = list.size();
    System.out.println("集合的长度是：" + size);
}

}

7.string_array_math

7.0创建字符串的常见3+1种方式。

三种构造方法：
public String()：创建一个空白字符串，不含有任何内容。
public String(char[] array)：根据字符数组的内容，来创建对应的字符串。
public String(byte[] array)：根据字节数组的内容，来创建对应的字符串。
一种直接创建：
String str = “Hello”; // 右边直接用双引号

    注意：直接写上双引号，就是字符串对象。
    */

public class String_Fang_Fa {
public static void main(String[] args) {
// 使用空参构造
String str1 = new String(); // 小括号留空，说明字符串什么内容都没有。
System.out.println(“第1个字符串：” + str1);

    // 根据字符数组创建字符串
    char[] charArray = { 'A', 'B', 'C' };
    String str2 = new String(charArray);
    System.out.println("第2个字符串：" + str2);//ABC

    // 根据字节数组创建字符串
    byte[] byteArray = { 97, 98, 99 };
    String str3 = new String(byteArray);
    System.out.println("第3个字符串：" + str3);//abc

    // 直接创建
    String str4 = "Hello";
    System.out.println("第4个字符串：" + str4);//Hello
}

}

7.1.比较

/*
==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法：

public boolean equals(Object obj)：参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true；否则返回false。
注意事项：

1. 任何对象都能用Object进行接收。
2. equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。
3. 如果比较双方一个常量一个变量，推荐把常量字符串写在前面。
   推荐：“abc”.equals(str) 不推荐：str.equals(“abc”)

public boolean equalsIgnoreCase(String str)：忽略大小写，进行内容比较。
*/
public class Bi_Jiao1 {
public static void main(String[] args) {
String str1 = “Hello”;
String str2 = “Hello”;
char[] charArray = {‘H’, ‘e’, ‘l’, ‘l’, ‘o’};
String str3 = new String(charArray);

    System.out.println(str1.equals(str2)); // true
    System.out.println(str2.equals(str3)); // true
    System.out.println(str3.equals("Hello")); // true
    System.out.println("Hello".equals(str1)); // true

    String str4 = "hello";
    System.out.println(str1.equals(str4)); // false
    System.out.println("=================");

    String str5 = null;
    System.out.println("abc".equals(str5)); // 推荐：false

// System.out.println(str5.equals(“abc”)); // 不推荐：报错，空指针异常NullPointerException
System.out.println("=================");

    String strA = "Java";
    String strB = "java";
    System.out.println(strA.equals(strB)); // false，严格区分大小写
    System.out.println(strA.equalsIgnoreCase(strB)); // true，忽略大小写

    // 注意，只有英文字母区分大小写，其他都不区分大小写
    System.out.println("abc一123".equalsIgnoreCase("abc壹123")); // false
}

}

/*
字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中。

对于基本类型来说，==是进行数值的比较。
对于引用类型来说，==是进行【地址值】的比较。
*/
public class Bi_jIao {
public static void main(String[] args) {
String str1 = “abc”;
String str2 = “abc”;

    char[] charArray = {'a', 'b', 'c'};
    String str3 = new String(charArray);

    System.out.println(str1 == str2); // true
    System.out.println(str1 == str3); // false
    System.out.println(str2 == str3); // false
}

}

7.2数组按照默认格式变成字符串

/*
java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。

public static String toString(数组)：将参数数组变成字符串（按照默认格式：[元素1, 元素2, 元素3…]）
public static void sort(数组)：按照默认升序（从小到大）对数组的元素进行排序。

备注：

1. 如果是数值，sort默认按照升序从小到大

2. 如果是字符串，sort默认按照字母升序

3. 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。（今后学习）
   */
   public class CanShuShuZu_ZiFuChuan {
   public static void main(String[] args) {
   int[] intArray = {10, 20, 30};
   // 将int[]数组按照默认格式变成字符串
   String intStr = Arrays.toString(intArray);
   System.out.println(intStr); // [10, 20, 30]

    int[] array1 = {2, 1, 3, 10, 6};
    Arrays.sort(array1);
    System.out.println(Arrays.toString(array1)); // [1, 2, 3, 6, 10]
   
    String[] array2 = {"bbb", "aaa", "ccc"};
    Arrays.sort(array2);
    System.out.println(Arrays.toString(array2)); // [aaa, bbb, ccc]
   

   }

}

8.String当中与获取相关的常用方法有：

8.0.转换

/*
String当中与转换相关的常用方法有：

public char[] toCharArray()：将当前字符串拆分成为字符数组作为返回值。
public byte[] getBytes()：获得当前字符串底层的字节数组。
public String replace(CharSequence oldString, CharSequence newString)：
将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。
备注：CharSequence意思就是说可以接受字符串类型。
*/
public class Zhuan_Huan {
public static void main(String[] args) {
// 转换成为字符数组
char[] chars = “Hello”.toCharArray();
System.out.println(chars[0]); // H
System.out.println(chars.length); // 5
System.out.println("==============");

    // 转换成为字节数组
    byte[] bytes = "abc".getBytes();
    for (int i = 0; i < bytes.length; i++) {
        System.out.println(bytes[i]);
    }
    System.out.println("==============");

    // 字符串的内容替换
    String str1 = "How do you do?";
    String str2 = str1.replace("o", "*");
    System.out.println(str1); // How do you do?
    System.out.println(str2); // H*w d* y*u d*?
    System.out.println("==============");

    String lang1 = "会不会玩儿呀！你大爷的！你大爷的！你大爷的！！！";
    String lang2 = lang1.replace("你大爷的", "****");
    System.out.println(lang2); // 会不会玩儿呀！****！****！****！！！
}

}

8.0.1字符串转字符数组

//字符串装进字符数组
String str1=“aaa”;
String str2=“bbb”;
String str3=“ccc”;
ArrayList list=new ArrayList();
list.add(str1);
list.add(str2);
list.add(str3);
System.out.println(list);//[aaa, bbb, ccc]

    //字符串转字符数组
    String myString = "hello123"; //创建一个字符串变量myString
    char[] myCharArray; //创建一个字符数组myCharArray
    myCharArray = myString.toCharArray(); //将字符串变量转换为字符数组
    for(int i=0; i<myCharArray.length; i++) {
        System.out.print(myCharArray[i] + " "); //将每个字符打印出来h e l l o 1 2 3
    }
   /* java可以使用两种方法直接将字符串转为字符数组
            * 情况一：如果是有分隔符的那种例如”abc,def,ghi”;就直接分割就行了.
            String string = “abc,def,ghi”;
    String [] strArr= string.split(“,”); //注意分隔符是需要转译

• 情况二：如果是”abcdefghijk”这种字符串,就直接
  String string1 = “abcdefghijk” ;
  char [] strArr1 = string1.toCharArray(); //注意返回值是char数组
  */
  // 将字符串转为字符串数组
  // 方法一
  String string = “abc,def,ghi”;
  String[] strArr = string.split(",");//注意分隔符是需要转译
  for (int i = 0; i < strArr.length; i++) {
  System.out.println(strArr[i]);
  }
  // 方法二
  String string1 = “abcdefghijk”;
  char[] strArr1 = string1.toCharArray();
  for (int i = 0; i < strArr1.length; i++) {
  System.out.println(strArr1[i]);
  }

  }
  }

8.0.2字符数组转字符串

8.1public int length()：获取字符串当中含有的字符个数，拿到字符串长度。

    int length = "asdasfeutrvauevbueyvb".length();
    System.out.println("字符串的长度是：" + length);//21

8.2public String concat(String str)：将当前字符串和参数字符串拼接成为返回值新的字符串

    String str1 = "Hello";
    String str2 = "World";
    String str3 = str1.concat(str2);
    System.out.println(str1); // Hello，原封不动
    System.out.println(str2); // World，原封不动
    System.out.println(str3); // HelloWorld，新的字符串
    System.out.println("==============");

。

8.3public char charAt(int index)：获取指定索引位置的单个字符。（索引从0开始。）

    char ch = "Hello".charAt(1);
    System.out.println("在1号索引位置的字符是：" + ch);//Hello

8.4public int indexOf(String str)：查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1值。

    String original = "HelloWorldHelloWorld";
    int index = original.indexOf("llo");
    System.out.println("第一次索引值是：" + index); // 2

    System.out.println("HelloWorld".indexOf("abc")); // -1

8.5字符串的截取方法：

public String substring(int index)：截取从参数位置一直到字符串末尾，返回新字符串。
public String substring(int begin, int end)：截取从begin开始，一直到end结束，中间的字符串。
备注：[begin,end)，包含左边，不包含右边。
*/
public class Jie_Qu {
public static void main(String[] args) {
String str1 = “HelloWorld”;
String str2 = str1.substring(5);
System.out.println(str1); // HelloWorld，原封不动
System.out.println(str2); // World，新字符串
System.out.println("================");

    String str3 = str1.substring(4, 7);
    System.out.println(str3); // oWo
    System.out.println("================");

    // 下面这种写法，字符串的内容仍然是没有改变的
    // 下面有两个字符串："Hello"，"Java"
    // strA当中保存的是地址值。
    // 本来地址值是Hello的0x666，
    // 后来地址值变成了Java的0x999
    String strA = "Hello";
    System.out.println(strA); // Hello
    strA = "Java";
    System.out.println(strA); // Java
}

8.6.数组拼接成一个字符串

分析：

1. 首先准备一个int[]数组，内容是：1、2、3

2. 定义一个方法，用来将数组变成字符串
   三要素
   返回值类型：String
   方法名称：fromArrayToString
   参数列表：int[]

3. 格式：[word1#word2#word3]
   用到：for循环、字符串拼接、每个数组元素之前都有一个word字样、分隔使用的是#、区分一下是不是最后一个

4. 调用方法，得到返回值，并打印结果字符串
   */
   public class Pin_Jie {
   public static void main(String[] args) {
   int[] array = {1, 2, 3, 4};

    String result = fromArrayToString(array);
    System.out.println(result);
   

   }

   public static String fromArrayToString(int[] array) {
   String str = “[”;
   for (int i = 0; i < array.length; i++) {
   if (i == array.length - 1) {
   str += “word” + array[i] + “]”;
   } else {
   str += “word” + array[i] + “#”;
   }
   }
   return str;
   }

}

9.Math(计算)

/*
题目：

9.1.计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？

分析：

1. 既然已经确定了范围，for循环
2. 起点位置-10.8应该转换成为-10，两种办法：
   2.1 可以使用Math.ceil方法，向上（向正方向）取整
   2.2 强转成为int，自动舍弃所有小数位
3. 每一个数字都是整数，所以步进表达式应该是num++，这样每次都是+1的。
4. 如何拿到绝对值：Math.abs方法。
5. 一旦发现了一个数字，需要让计数器++进行统计。

备注：如果使用Math.ceil方法，-10.8可以变成-10.0。注意double也是可以进行++的。
*/
int count = 0; // 符合要求的数量

    double min = -10.8;
    double max = 5.9;
    // 这样处理，变量i就是区间之内所有的整数
    for (int i = (int) min; i < max; i++) {
        int abs = Math.abs(i); // 绝对值
        if (abs > 6 || abs < 2.1) {
            System.out.println(i);
            count++;
        }
    }

    System.out.println("总共有：" + count); // 9
}

9.2.取值

// 获取绝对值
System.out.println(Math.abs(3.14)); // 3.14
System.out.println(Math.abs(0)); // 0
System.out.println(Math.abs(-2.5)); // 2.5
System.out.println("================");

    // 向上取整
    System.out.println(Math.ceil(3.9)); // 4.0
    System.out.println(Math.ceil(3.1)); // 4.0
    System.out.println(Math.ceil(3.0)); // 3.0
    System.out.println("================");

    // 向下取整，抹零
    System.out.println(Math.floor(30.1)); // 30.0
    System.out.println(Math.floor(30.9)); // 30.0
    System.out.println(Math.floor(31.0)); // 31.0
    System.out.println("================");

    System.out.println(Math.round(20.4)); // 20
    System.out.println(Math.round(10.5)); // 11
}

}

9.3.统计统计其中各种字符出现的次数。

种类有：大写字母、小写字母、数字、其他
思路：

1. 既然用到键盘输入，肯定是Scanner

2. 键盘输入的是字符串，那么：String str = sc.next();

3. 定义四个变量，分别代表四种字符各自的出现次数。

4. 需要对字符串一个字、一个字检查，String–>char[]，方法就是toCharArray()

5. 遍历char[]字符数组，对当前字符的种类进行判断，并且用四个变量进行++动作。

6. 打印输出四个变量，分别代表四种字符出现次数。
   */
   public class Tong_Ji {
   public static void main(String[] args) {
   Scanner sc = new Scanner(System.in);
   System.out.println(“请输入一个字符串：”);
   String input = sc.next(); // 获取键盘输入的一个字符串

    int countUpper = 0; // 大写字母
    int countLower = 0; // 小写字母
    int countNumber = 0; // 数字
    int countOther = 0; // 其他字符
   
    char[] charArray = input.toCharArray();
    for (int i = 0; i < charArray.length; i++) {
        char ch = charArray[i]; // 当前单个字符
        if ('A' <= ch && ch <= 'Z') {
            countUpper++;
        } else if ('a' <= ch && ch <= 'z') {
            countLower++;
        } else if ('0' <= ch && ch <= '9') {
            countNumber++;
        } else {
            countOther++;
        }
    }
   
    System.out.println("大写字母有：" + countUpper);
    System.out.println("小写字母有：" + countLower);
    System.out.println("数字有：" + countNumber);
    System.out.println("其他字符有：" + countOther);
   

   }

}

10.继承，抽象类

10.1抽象类

/*
一个抽象类不一定含有抽象方法，
只要保证抽象方法所在的类是抽象类，即可。

这样没有抽象方法的抽象类，也不能直接创建对象，在一些特殊场景下有用途。
*/

10.2继承

*面向对象的三大特征：封装，继承，多态

• 继承是多态的前提，没有继承就没有多态
• 特点：

•  1.子类可以有父类的内容
  

•  2.子类有自己的专有的内容
  

10.3重写

/*
第1章 继承
1.1 继承的概述
在现实生活中，继承一般指的是子女继承父辈的财产。在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系。
1.2 继承的格式&使用
在程序中，如果想声明一个类继承另一个类，需要使用extends关键字。

格式：
class 子类 extends 父类 {}

1
2
1.3 继承的特点
在类的继承中，需要注意一些问题，具体如下：
1、在Java中，类只支持单继承，不允许多继承，也就是说一个类只能有一个直接父类，例如下面这种情况是不合法的。
class A{}
class B{}
class C extends A,B{} // C类不可以同时继承A类和B类
2、多个类可以继承一个父类，例如下面这种情况是允许的。
class A{}
class B extends A{}
class C extends A{} // 类B和类C都可以继承类A
3、在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类，例如C类继承自B类，而B类又可以去继承A类，这时，C类也可称作A类的子类。下面这种情况是允许的。
class A{}
class B extends A{} // 类B继承类A，类B是类A的子类
class C extends B{} // 类C继承类B，类C是类B的子类，同时也是类A的子类
4、在Java中，子类和父类是一种相对概念，也就是说一个类是某个类父类的同时，也可以是另一个类的子类。例如上面的这种情况中，B类是A类的子类，同时又是C类的父类
Java中继承的特点：

•  	Java语言只支持单一继承，只能继承一个父类（一个儿子只能有一个亲爹）
  

•  	Java语言支持多层继承（一个儿子可以有一个亲爹，还可以有一个亲爷爷）
  

• /*
• 继承中成员变量的特点

•  子类只能获取父类非私有成员
  

•  子父类中成员变量的名字不一样直接获取父类的成员变量
  

•  子父类中成员变量名字是一样的获取的是子类的成员变量
  

• 就近原则：谁离我近我就用谁

•  如果有局部变量就使用局部变量
  

•  如果没有局部变量，有子类的成员变量就使用子类的成员变量
  

•  如果没有局部变量和子类的成员变量，有父类的成员变量就使用父类的成员变量
  

•  啥都没有，出错了！！！
  

• super:可以获取父类的成员变量和成员方法,用法和this是相似的

在父子类的继承关系当中，创建子类对象，访问成员方法的规则：
创建的对象是谁，就优先用谁，如果没有则向上找。

注意事项：
无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。

重写（Override）
概念：在继承关系当中，方法的名称一样，参数列表也一样。

重写（Override）：方法的名称一样，参数列表【也一样】。覆盖、覆写。
重载（Overload）：方法的名称一样，参数列表【不一样】。

方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。
用用场景：

10.4super

super关键字用来访问父类内容，而this关键字用来访问本类内容。用法也有三种：

1. 在本类的成员方法中，访问本类的成员变量。
2. 在本类的成员方法中，访问本类的另一个成员方法。
3. 在本类的构造方法中，访问本类的另一个构造方法。
   在第三种用法当中要注意：
   A. this(…)调用也必须是构造方法的第一个语句，唯一一个。
   B. super和this两种构造调用，不能同时使用。
   */

10.5抽象方法

super关键字用来访问父类内容，而this关键字用来访问本类内容。用法也有三种：

1. 在本类的成员方法中，访问本类的成员变量。
2. 在本类的成员方法中，访问本类的另一个成员方法。
3. 在本类的构造方法中，访问本类的另一个构造方法。
   在第三种用法当中要注意：
   A. this(…)调用也必须是构造方法的第一个语句，唯一一个。
   B. super和this两种构造调用，不能同时使用。
   */

11.接口多态

/*
接口就是多个类的公共规范。
接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。

如何定义一个接口的格式：
public interface 接口名称 {
// 接口内容
}

备注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java --> .class。

如果是Java 7，那么接口中可以包含的内容有：

1. 常量
2. 抽象方法

如果是Java 8，还可以额外包含有：
3. 默认方法
4. 静态方法

如果是Java 9，还可以额外包含有：
5. 私有方法

接口使用步骤：

1. 接口不能直接使用，必须有一个“实现类”来“实现”该接口。
   格式：
   public class 实现类名称 implements 接口名称 {
   // …
   }
2. 接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。
   实现：去掉abstract关键字，加上方法体大括号。
3. 创建实现类的对象，进行使用。

注意事项：
如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。
*/

12.权限范围public > protected > (default) > private

注意：default 并不是关键字，不写
*/

13.区别

1.==和equals

“ == ” 运算符

equals（） 方法

区别：

“ == ” 运算符所进行的是所引用对象的内存地址是否一致

equals（）方法是String类中的方法，其所进行的是两个对象引用所指的内容是否相同的比较

2.接口和抽象类

2.1抽象类：

1、抽象类使用abstract修饰；
2、抽象类不能实例化，即不能使用new关键字来实例化对象；
3、含有抽象方法（使用abstract关键字修饰的方法）的类是抽象类，必须使用abstract关键字修饰；
4、抽象类可以含有抽象方法，也可以不包含抽象方法，抽象类中可以有具体的方法；  
5、如果一个子类实现了父类（抽象类）的所有抽象方法，那么该子类可以不必是抽象类，否则就是抽象类；
6、抽象类中的抽象方法只有方法体，没有具体实现；

2.2接口：

1、接口使用interface修饰；
2、接口不能被实例化；
3、一个类只能继承一个类，但是可以实现多个接口；
4、接口中方法均为抽象方法；
5、接口中不能包含实例域或静态方法（静态方法必须实现，接口中方法是抽象方法，不能实现）

3.重写和重载

4.StringBuffer 和 StringBuilder 类

对String而言：

String是只读字符串，所引用的字符串不能被改变，一经定义，无法再增删改。

String 定义的字符串保存在常量池里面，进行+操作时不能直接在原有基础上拼接。

每次+操作 ： 隐式在堆上new了一个跟原字符串相同的StringBuilder对象，再调用append方法 拼接+后面的字符。

例如：

String str1=“ss”; StringBuilder str2=new StringBuilder(ss);
str1=str1+“oo”; 等于 str2.append(oo);
（Java6和6之前，常量池是存放在方法区中的。

Java7，将常量池是存放到了堆中，常量池就相当于是在永久代中，所以永久代存放在堆中。

Java8之后，取消了整个永久代区域，取而代之的是元空间。没有再对常量池进行调整。）

区别

String是只读字符串，所引用的字符串不能被改变，Stringbuffer和Stringbuilder定义的可以通过各种方法来达到简单的增删改；

String和Stringbuilder在单线程环境下使用；

StringBuffer在多线程环境下使用，可以保证线程同步；

Stringbuilder 和StringBuffer 实现方法类似，均表示可变字符序列，不过StringBuffer 用synchronized关键字修饰（保证线程同步）

运行速度

当需要对某一字符串大量重复+操作时：

Stringbuilder 最快，不需要考虑线程同步；

StringBuffer次之；

String最慢，因为每次都要重新开辟内存，产生很多匿名对象，影响系统性能。