day10day11day12

=====接口的默认修饰符public static final
 例如：
 public static final int NUM=100;
 public static final String name="haha";
 省略前面默认修饰符也是可以的，但是尽量不要省略
 void jump();
=====抽象类和接口有什么区别
  ==1.抽象类有构造方法，接口没有构造方法
  ==2.抽象类中的有成员变量，有常量， 接口中他全是静态常量
  ==3.在JDK1.7之前，接口中全部是抽象方法  抽象类中有抽象方法，也可以有非抽象方法
  ==4.抽象类跟接口在思想上的区别：抽象类是一种 is a 什么是什么的一种  接口定义一些扩展的功能，其实接口是定义一些规范的

=====JDK1.8 中我们可以定义三种形式的方法
 == 1.定义抽象方法
  public abstract void show(String name);
 == 2. 定义默认方法
  default void haha() {}/定义默认修饰需要default
 == 3.定义静态方法
  public static void hehe() {}
=====如果一个类，同时实现了两个接口，如果这两个接口中 有同名的默认方法，
     那子类必须重写默认的方法。
=====类优先原则
=====传参问题
  传参数：如果以后你看到一个方法，要一个 类 类型你就传一个该类的对象
  
  传参数：如果你以后看到一个方法要的参数是一个 抽象类 类型，就传该抽象类的子类对象
  
  传参数： 如果你以后看到一个方法要的参数是一个接口类型，你就传一个实现了该接口的子类对象
  

=====返回值问题的研究
  如果看到一个方法的返回值 要一个类 类型 你就返回一个该类的对象
  
  如果看到一个方法的返回值类型 要一个抽象类类型 你就返回一个该抽象类的子类对象
  
  如果看到一个方法的返回值类型，要一个接口类型，你就返回一个实现了该接口的子类对象
=====链式编程 ：当一个对象 调用完一个方法之后，又返回一个对象，那我继续就可以使用这个对象打点再去调用他对应的方法
  链式编程 连调
=====内部类：将一个类，定义到另一个类的内部，我们就称之为内部类
 ===那内部类根据定义位置的不同细分为两种：成员内部类 局部内部类
 ===成员位置：类中方法外
 ===局部位置：在方法中
=====如何使用局部内部类
=====创建成员内部类对象的格式: 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
 Student.Inner in = new Student().new Inner();
=====   内部类 要访问外部类的成员变量，和成员方法都是可以直接访问，包括私有的
  ===但是内部类 被private 修饰后，外界不能创建其对象
  ===内部被静态修饰后，只能访问外部类静态的成员
     外部类名.内部类名 对象名 = new 外部类名.内部类名();

 外部类，要访问内部类的成员 我们得创建内部类的对象 通过对象去访问

===成员内部类（定义在一个类中的成员位置）
   局部内部类（定义在一个类中的方法里面）
  局部内部类 在外界不能之间创建其对象
  局部内部类访问外部类的成员，可以直接访问包括私有的
  
===常量是存在方法区的常量池中
  要访问外部类的局部变量这个局部变量必须加上final 让其变成一个常量
=====匿名内部类
  匿名内部类：她是局部内部类的一种简写方式
 语法：
  new 类名，接口名，抽象类名(){}
 匿名内部类的本质是一个对象
  是一个继承了该抽象类的子类对象
  或者实现了该接口的子类对象
===一个类是可以定义一个内部接口的

=====Object：此类是所有类的顶层父类，所有类都是直接或间接继承自他
=====getClass() 返回一个类的字节码文件对象.class
=====hashCode() 返回一个对象的哈希代码值
=====toString() 返回对象的字符串表示形式
 如果用对象调用toString()方法打印出来的是一个地址值，说明此类没有重写toString();
=====Object 类里面有一个
 boolean equals(Object obj) 比较两个对象的地址值是否相等
 这个equals方法默认是比较两个对象的地址值，但通常情况下这样的比较没有意义
 所以我们需要对其进行改写，比如比较两个对象的成员变量
例如：重写equals方法比较两个成员变量的值是否相等
@Override
 public boolean equals(Object obj) {
  if (this == obj)
   return true;
  if (obj == null)
   return false;
  if (getClass() != obj.getClass())
   return false;
  Dog other = (Dog) obj;
  if (age != other.age)
   return false;
  if (name == null) {
   if (other.name != null)
    return false;
  } else if (!name.equals(other.name))
   return false;
  return true;
 }

=====instansof 判断一个引用是不是该类的一种类型

=====equals() 和 == 区别?
  1.equals() 是一个方法 == 是一个比较运算符
  2.== 既能比较基本数据类型，比较基本数据类型是比较两个值是否相等，==表引用数据类型，是比较两个地址值是否相等
  3.equals() 只能比较引用数据类型 默认是比较两个地址值是否相等
  4.我们认为 equals()默认的比较方式意义不大，所有我们一般来说，我们都会去重写equals()方法去比较我们认为有意的东西
   比如比较两个对象的成员变量的值是否相同

=====Scanner 用于接收键盘录入的数据
 public int nextInt():获取一个int类型的值

 public String next():获取一个String类型的值
 
 .close();用来关闭扫描器释放资源

=====字符串：字符串是由多个字符组成的一串数据(字符序列)
  字符串是有角标的 从0开始数

=====String 类代表字符串
 字符串常量其实就是String类的一个对象，字符串是常量，一旦被创建就不能被改变
 字符串本身的内容不能被改变

=== public String(byte[] bytes):把字节数组转成字符串
=== public String(byte[] bytes,int index,int length):
 把字节数组的一部分转成字符串(index:表示的是从第几个索引开始, length表示的是长度)
=== public String(char[] value):把字符数组转成字符串
=== public String(char[] value,int index,int count):把字符数组的一部分转成字符串

===我们在定义一个字符串的时候，会先去方法区的常量池里面去找这个字符串
   如果有就不重复开辟空间,如果没有就为这个字符串常量开辟空间

=====boolean判断方法

===public boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
===public boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小public boolean contains(String str): 判断字符串中是否包含传递进来的字符串
===public boolean startsWith(String str): 判断字符串是否以传递进来的字符串开头
===public boolean endsWith(String str):判断字符串是否以传递进来的字符串结尾
===public boolean isEmpty(): 判断字符串的内容是否为空串""。

案例演示: 需求：模拟登录,给三次机会,并提示还有几次。
package org.westos.demo3;

import java.util.Scanner;

public class Test2 {
 public static void main(String[] args) {
  
  String username = "zhangsan";
  String password = "123456";
  Scanner sc = new Scanner(System.in);
  for (int i = 1; i <= 3; i++) {
   System.out.println("请输入用户名");
   String name = sc.next();
   System.out.println("请输入密码");
   String pwd = sc.next();
   if (name.equals(username) && pwd.equals(password)) {
    System.out.println("登录成功");
    break;
   } else {
    System.out.println("用户名或密码错误，你还剩" + (3 - i) + "次机会");
    if ((3 - i) == 0) {
     System.out.println("你今天的次数已经用完");
    }

   }

  }
 }

}

=====String类的获取功能
  public int length():获取字符串的长度。
  public char charAt(int index):获取指定索引位置的字符
  public int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
  public int indexOf(String str): 返回指定字符串在此字符串中第一次出现处的索引。
  public int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
  public int indexOf(String str,intfromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
  lastIndexOf
  public String substring(int start):从指定位置开始截取字符串,默认到末尾。
  public String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。含头不含尾。

遍历字符串用到charAt

for (int i = 0; i < str.length(); i++) {
   char ch = str.charAt(i);
   System.out.println(ch);

=====String的转换功能：
  public byte[] getBytes():把字符串转换为字节数组。
  public char[] toCharArray():把字符串转换为字符数组。
  public static String valueOf(char[] chs):把字符数组转成字符串。
  public static String valueOf(int i):把int类型的数据转成字符串。
  注意：String类的valueOf方法可以把任意类型的数据转成字符串。
  public String toLowerCase():把字符串转成小写。
  public String toUpperCase():把字符串转成大写。
  public String concat(String str):把字符串拼接。

案例演示: 需求：把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)
package org.westos.demo;

public class Test2 {

 public static void main(String[] args) {
  
  String str = "aSsasdfsdQQQWWW";
  String str2 = String.valueOf(str.charAt(0)).toUpperCase().concat(str.substring(1).toLowerCase());
  //使用连调的方法比较简便
  System.out.println(str2);
 }
}

=====String的替换功能及案例演示
  public String replace(char old,char new)将指定字符进行互换
  public String replace(String old,String new)将指定字符串进行互换

=====String的去除字符串两空格

  public String trim()去除两端空格

=====String的按字典顺序比较两个字符串
  public int compareTo(String str) 会对照ASCII 码表 从第一个字母进行减法运算
  返回的就是这个减法的结果
  如果前面几个字母一样会根据两个字符串的长度进行减法运算返回的就是这个减法的结果
  如果两个字符串一摸一样 返回的就是0
  public int compareToIgnoreCase(String str) 跟上面一样 只是忽略大小写的比较

/
案例演示
  需求：把数组中的数据按照指定个格式拼接成一个字符串
  举例：
  int[] arr = {1,2,3};
  拼接结果：
  "[1, 2, 3]"
///
  int[] arr = { 1, 2, 3 };
  String str = "[";
  for (int i = 0; i < arr.length; i++) {
   if (i == arr.length - 1) {
    // str += arr[i] + "]";
    str = str.concat(arr[i] + "]");
   } else {
    // str += arr[i] + ",";
    str = str.concat(arr[i] + ",");
   }

  }

//