字符串
1.内容不可改变
2.可以共享使用
3.效果上相当于char[]数组，但是底层原理是byte
三种构造
public String()
public String(char[] array)
public String(byte[] array)
用双引号直接写的字符串，就在字符串常量池中
对于基本类型 == 是数值比较
对于引用类型 ==是地址比较
public int length () ： 返回此字符串的长度。
public String concat (String str) ： 将指定的字符串连接到该字符串的末尾。
public char charAt (int index) ： 返回指定索引处的 char值。
public int indexOf (String str) ： 返回指定子字符串第一次出现在该字符串内的索引。
public String substring (int beginIndex) ： 返回一个子字符串，从beginIndex开始截取字符串到字符
串结尾。
public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到
endIndex截取字符串。含beginIndex，不含endIndex。
public class DemoString {
public static void main(String[] args) {
String str1 = "dvvdvdvsdscascavbae";
int length = str1.length();
System.out.println( length);
String str2 = "hello";
String str3 = "world";
String str4 = str2.concat(str3);
System.out.println(str4);
char ch = str4.charAt(5);
System.out.println(ch);
System.out.println(str4.indexOf("llo"));
System.out.println(str4.indexOf("fe"));
}
}
字符串截取
subString（）
转换功能的方法
public char[] toCharArray () ： 将此字符串转换为新的字符数组。
public byte[] getBytes () ： 使用平台的默认字符集将该 String编码转换为新的字节数组。
public String replace (CharSequence target, CharSequence replacement)
都会创建一个新的string，而不会修改原string
分割
public String[] split(String regex)
regex参数其实是个正则表达式若按照 . 切分， 必须写\.
练习1
定义一个方法，把数组{1,2,3}按照指定个格式拼接成一个字符串。格式参照如下：[word1#word2#word3]。
package Day4.java;
public class DemoString {
public static void main(String[] args) {
int[] array = {1,2,3};
String s = tranmit(array);
System.out.println(s);
}
public static String tranmit(int[] arr) {
String string = new String("[");
for(int i =0;i<arr.length;i++) {
if(i==arr.length-1) {
string = string.concat("word"+arr[i]+"]");
}else {
string = string.concat("word"+arr[i]+"#");
}
}
return string;
}
}
2....
键盘录入一个字符，统计字符串中大小写字母及数字字符个数
import java.util.Scanner;
public class DemoString {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("Please input");
String str = sc.next();
int Upper = 0;
int Lower = 0;
int number = 0;
int another = 0;
char[] array = str.toCharArray();
for(int i = 0;i<array.length;i++) {
char ch = array[i];
if('A'<= ch && ch <= 'Z') {
Upper+=1;
}else if ('a'<= ch && ch <= 'z') {
Lower+=1;
}else if ('0'<= ch && ch <='9') {
number+=1;
}else {
another+=1;
}
}
System.out.println(Upper);
System.out.println(Lower);
System.out.println(number);
System.out.println(another);
}
}
static关键字
一旦使用了static，这样的内容不再属于自己，而是属于类
所以凡是本类的对象，都共享一份
静态方法
1.可以直接访问类变量和静态方法。
2.不能直接访问普通成员变量或成员方法（非静态）
3.不能使用this关键字。
静态代码快
第一次用到本类的时候，静态代码快执行唯一一次
Arrays类
toString(int[] a) ：返回指定数组内容的字符串表示形式。
sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。
如果是自定义类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持
将一个随机字符串中的所有字符升序排列，并倒序打印。
import java.util.Arrays;
public class Array {
public static void main(String[] args) {
String line = "ysKUreaytWTRHsgFdSAoidq";
char[] ch = line.toCharArray();
System.out.println();
Arrays.sort(ch);
for(int i = ch.length-1;i>=0;i--) {
System.out.print(ch[i]);
}
}
}
math小练习
求-10.8到5.9之间所欲绝对值男足条件的整数个数
import java.lang.Math;
public class Array {
public static void main(String[] args) {
double min_num = -10.8;
double max_num = 5.9;
int Count = 0;
for(double i = Math.ceil(min_num);i<=max_num;i++)
{
if (Math.abs(i)>=6 || Math.abs(i)<=2.1 ) {
Count+=1;
}
}
System.out.println(Count);
}
}
继承
解决的问题：共性抽取
定义 public class 子类名称 extend 类名称{}
如果子类父类中出现重名的成员变量，这时的访问规则
直接通过子类对象访问
等号左边是谁就优先用谁，没有则向上找
间接通过成员方法访问
方法属于谁就优先用谁，没有则向上找
局部变量 直接写
本类的成员变量 this.成员变量名
父类的成员变量 super.成员变量名
public class DemoExtendsFiled {
public static void main(String[] args) {
Zi zi = new Zi();
zi.method();
}
}
public class Fu {
int num = 10;
}
public class Zi extends Fu {
int num = 20;
public void method() {
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
}
}
当父子类的方法重名
创建的对象是谁，就优先用谁，如果没有则向上找
无论是成员变量还是方法，找不到的时候，都是向上找父类
方法覆盖重写： 创建的是子类对象，则优先用子类方法
@Override 写在方法前面，检测是否为有效的复写
1,父子类的方法名称相同，参数列表相同
2.子类的返回值范围必须不超过父类
3.子类方法的权限必须大于父类的权限修饰符
public > protect > (default) 空 > private
重写的应用
class Phone {
public void sendMessage(){
System.out.println("发短信");
}
public void call(){
System.out.println("打电话");
}
public void showNum(){
System.out.println("来电显示号码");
}
}
//智能手机类
class NewPhone extends Phone {
//重写父类的来电显示号码功能，并增加自己的显示姓名和图片功能
public void showNum(){
//调用父类已经存在的功能使用super
super.showNum();
//增加自己特有显示姓名和图片功能
System.out.println("显示来电姓名");
System.out.println("显示头像");
}
}
public class ExtendsDemo06 {
public static void main(String[] args) {
// 创建子类对象
NewPhone np = new NewPhone()；
// 调用父类继承而来的方法
np.call();
// 调用子类重写的方法
np.showNum();
}
}
继承后的特点——构造方法
构造方法的名字是与类名一致的。子类是无法继承父类构造方法。
1.子类有一个默认的super（），所以一定先调用父
2.可以通过super来子类构造调用重载构造
3.super的父类构造，必须是子类方法的第一个语句（即一个子类构造调用多次父类构造）
public class Fu {
public Fu() {
System.out.println("Fu");
}
public Fu(int num) {
System.out.println("FuFu");
}
}
public class Zi extends Fu{
public Zi() {
super(20);
System.out.println("zi");
}
}
public class DEext {
public static void main(String[] args) {
Zi zi = new Zi();
}
}
输出：
FuFu
zi
this关键字，用来访问本类内容
继承的特点
1. Java只支持单继承，不支持多继承。
//一个类只能有一个父类，不可以有多个父类。
class C extends A{} //ok
class C extends A，B... //error
2. Java支持多层继承(继承体系)。
class A{}
class B extends A{}
class C extends B{}
顶层父类是Object类。所有的类默认继承Object，作为父类。
3. 子类和父类是一种相对的概念。
抽象类
父类中的方法不确定如何进行{}方法体实现，那么该方法就是一个抽象方法
如果一个类包含抽象方法，那么该类必须是抽象类
public abstract void name（）；并在类名前加abstract
1.不能直接new创建抽象类对象
2.必须用一个子类继承父类
3.子类必须覆盖重写抽象父类方法中所有的抽象方法【去掉abstract，然后补上方法体大括号】
4.创建使用
public abstract class Animal {
public abstract void eat();
}
public class Cat extends Animal{
@Override
public void eat() {
System.out.println("cat eat fish");
}
}
public class DemoAnimal {
public static void main(String[] args) {
Cat cat = new Cat();
cat.eat();
}
}
注意事项
1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。
3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象
类。