面向对象

构造方法

Java 构造方法有以下特点：

方法名必须与类名相同

没有任何返回值，包括 void

构造方法中不能有return语句

可以有 0 个、1 个或多个参数

默认返回类型就是对象类型本身

只能与 new 运算符结合使用

注意事项：

1.如果自己没写构造方法，系统会默认一个无参的构造方法。供我们创建对象使用

2.如果我们写了构造方法，那么系统就不再提供空参的构造方法了

方法重载

同一类中方法名相同

参数列表不同（参数的个数不同，或数据类型不同）

方法返回值类型、修饰符等，与方法重载没有任何关系

方法重写

1.方法重写时， 方法名与形参列表、返回值类型必须一致。

2.方法重写时，子类的权限修饰符必须要大于或者等于父类的权限修饰符。

3.方法重写时，子类的返回值类型必须要小于或者 等于父类的返回值类型。

4.方法重写时， 子类抛出的异常类型要小于或者等于父类抛出的异常类型。 Exception(最坏) RuntimeException(小坏)

注意事项：

重写的方法可以使用 @Override 注解来标识。

父类的成员方法只能被它的子类重写。

声明为 final 的方法不能被重写。

声明为 static 的方法不能被重写，但是能够再次声明。

构造方法不能被重写。

子类和父类在同一个包中时，子类可以重写父类的所有方法，除了声明为 private 和 final 的方法。

子类和父类不在同一个包中时，子类只能重写父类的声明为 public 和 protected 的非 final 方法。

如果不能继承一个方法，则不能重写这个方法。

Super关键字

访问父类成员（方法和属性）

Final关键字

Final修饰的类（最后一个），不能被继承

修饰的方法，不能被重写

访问符

四种修饰符的访问权限

由大到小public>protected>default>private

public:对所有类可见

protected:对同一包中的类可见、对同一包及不同包中的子类可见

default:对同一包中的类可见、对同一包中的子类可见

private:仅对类本身可见

this的三种用法

调用成员变量

调用成员方法

调用构造方法

static关键字

修饰的变量或方法不用实例化对象就可以调用

类名.方法名()或类名.变量名=赋值

static只能修饰成员变量，不能修饰局部变量

什么时候使用？

当一个变量被共享的时候

补充：成员变量和局部变量的区别

1.在类中的位置不同

成员变量：类中方法外

局部变量：方法定义中或者方法声明上

2.初始化值不同

成员变量：有默认值

局部变量：没有默认值，必须定义，赋值，然后才能使用

继承extends

特点：只支持单继承，但可以多层继承。

继承父只能使用父类的公共成员。

每个类都默认继承了0bject类

抽象abstract

什么是抽象类：

当我们进行父类抽取的时候，有些方法具体每个子类的实现方式都不太一样时。那么这个时候，就应该把这个方法定义成抽象方法。有抽象方法的类一定是抽象类。

注意事项：

抽象类不能直接实例化对象使用

接口interface

定义：

// 常量

public static final int id =1;

//抽象方法

public abstract void eat();

//默认方法

public default void Type(String type) {

System.out.println(type);

}

//静态方法

public static int getId() {

return id;

}

接口与类的区别：

接口不能用于实例化对象。

接口没有构造方法。

接口中所有的方法必须是抽象方法。

接口不能包含成员变量，除了 static 和 final 变量。

接口不是被类继承了，而是要被类实现。

接口支持多重继承。

特点：

1.方法，语法 public abstract（只能是 public abstract）。

2、接口中变量，语法： （只能是public static final，默认的可以省略 ）变量

3、接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

抽象类和接口的区别

1.抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法无方法体。

2.抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。

3.接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。

4.一个类只能继承一个抽象类，而一个类却可以实现多个接口。

接口与类的关系

Implement实现接口，可以实现多接口

接口与接口的关系

继承关系

多态

前提条件：

1.要有继承（或实现接口）的关系

2.要有方法重写

3.要有父类引用指向子类对象

如：Animal a = new Dog();

关键字：instanceof

用于判断左边的引用是否为右边的对象类型

Animal a = new Dog();

If(a instanceof Dog)

向上转型：父类引用指向子类对象Animal a = new Dog();

向下转型：

Dog d = (Dog) a

成员内部类

//访问内部类成员

Outer.Inner in = new Outer().new Inner();

API

replace()替换

reverse()反转

String与stringBuffer

1.Character 是进行单个字符操作的，

2.String 对一串字符进行操作。不可变类。+连接字符串

3.StringBuffer 也是对一串字符进行操作，但是可变类。append（）拼接,可以反转reverse（）；

StringBuffer str2 = new StringBuffer(“peOple”);

//StringBuffer转换String

//方法一

String str1 = new String(str2);

//方法二

String str1 = str2.toString();

//string转StringBuffer

StringBuffer str2 = new StringBuffer(str1);

例题.计算从今天是算起，170天以后是几月几号，并格式化成XXXX年XX月XX日的形式输出。

提示：

①　调用Calendar类的add方法计算170以后的日期。

②　调用Calendar类的getTime方法返回Date类对象

使用SimpleDateFormat类的对象调用format方法输出指定格式的日期

public static void main(String[] args) {
    //获取当前时间
    Calendar c = Calendar.getInstance();
    c.add(Calendar.DATE,170);
    Date date = c.getTime();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
    System.out.println(sdf.format(date));
  }

例题.计算2021年4月25日和2020年7月8日之间间隔的天数。

提示：

①　创建SimpleDateFormat类的对象，指定日期格式化的格式

②　按照指定格式从键盘上输入日期字符串（和上面指定格式一致）

③　用SimpleDateFormat类的对象将输入日期字符串转换为Date类的对象

④　用Date对象的after方法求出天数差。

public static void main(String[] args) throws ParseException {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入第一个日期格式：2021-4-25");
    String str1 =sc.next();
    System.out.println("请输入第二个日期格式：2020-7-8");
    String str2 =sc.next();
    //SimpleDateFormat类的对象将输入日期字符串转换为Date类的对象
    Date date1 = sdf.parse(str1);
    Date date2 = sdf.parse(str2);
    int sum;
//    date1.after(date2)如果date1比date2大，返回true，否则返回false
    if(date1.after(date2)) {
      sum = (int)((date1.getTime()-date2.getTime())/(1000*3600*24));
    }else {
      sum = (int)((date2.getTime()-date1.getTime())/(1000*3600*24));
    }
    System.out.println("2021年4月25日和2020年7月8日之间间隔的天数是"+sum);
  }

回文数

//输入一个字符串判断是否是回文

//回文数：一个字符串反转过来和原来字符串一样

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入一个字符串");
    String str = sc.next();
    StringBuffer sb = new StringBuffer(str);
    //反转过来
    sb.reverse();
    int count = 0;
    //判断反转过来的每个字符和原来的是否都相等，统计相等的个数
    //charAt()方法返回指定索引位置的char值。索引范围为0~length()-1.
    for (int i = 0; i < str.length(); i++) {
      if (str.charAt(i) == sb.charAt(i)) {
        count++;
      }
    }
    //相等的个数与原来的字符串长度是否一致
    if (count == str.length()) {
      System.out.println(str+"-是一个回文字符串");
    } else {
      System.out.println(str+"-不是一个回文字符串");
    }
  }