Java基础学习笔记十二 类、抽象类、接口做为方法参数和返回值以及经常使用API（关键字：public ,protected ,private ,static ,final ,abstract ）Stri

不一样修饰符使用细节

经常使用来修饰类、方法、变量的修饰符

• public 权限修饰符，公共访问, 类,方法,成员变量
• protected 权限修饰符，受保护访问, 方法,成员变量
• 默认什么也不写 也是一种权限修饰符，默认访问, 类,方法,成员变量
• private 权限修饰符，私有访问, 方法,成员变量
• static 静态修饰符 方法,成员变量
• final 最终修饰符 类,方法,成员变量,局部变量
• abstract 抽象修饰符 类 ,方法

咱们编写程序时，权限修饰符通常放于全部修饰符以前，不一样的权限修饰符不能同时使用；

• 同时，abstract与private不能同时使用；
• 同时，abstract与static不能同时使用；
• 同时，abstract与final不能同时使用。

修饰类可以使用的修饰符

修饰类只能使用public、默认的、final、abstract关键字，使用最多的是 public关键字

public class Demo {} //最经常使用的方式
class Demo2{}
public final class Demo3{}
public abstract class Demo4{}

修饰成员变量可以使用的修饰符

• public : 公共的
• protected : 受保护的
• : 默认的
• private ：私有的
• final : 最终的
• static : 静态的

使用最多的是 private

public int count = 100;
protected int count2 = 100;
int count3 = 100;
private int count4 = 100; //最经常使用的方式
public final int count5 = 100;
public static int count6 = 100;

修饰构造方法可以使用的修饰符

• public : 公共的
• protected : 受保护的
• : 默认的
• private ：私有的

使用最多的是 public

public Demo(){} //最经常使用的方式
protected Demo(){}
Demo(){}
private Demo(){}

修饰成员方法可以使用的修饰符

• public : 公共的
• protected : 受保护的
• : 默认的
• private ：私有的
• final : 最终的
• static : 静态的
• abstract : 抽象的

使用最多的是 public

public void method1(){}//最经常使用的方式
protected void method2(){}
void method3(){}
private void method4(){}
public final void method5(){}
public static void method6(){}//最经常使用的方式
public abstract void method7();//最经常使用的方式

类做为方法参数与返回值

类做为方法参数

在编写程序中，会常常碰到调用的方法要接收的是一个类类型的状况，那么这时，要向方法中传入该类的对象。以下代码演示：

class Person{
    public void show(){
        System.out.println("show方法执行了");
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
//建立Person对象
        Person p = new Person();
//调用method方法
        method(p);
    }
    //定义一个方法method，用来接收一个Person对象，在方法中调用Person对象的show方法

    public static void method(Person p){
        p.show();
    }
}

类做为方法返回值

写程序调用方法时，咱们之后会常常碰到返回一个类类型的返回值，那么这时，该方法要返回一个该类的对象。以下代码演示：

class Person{
    public void show(){
        System.out.println("show方法执行了");
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
//调用method方法，获取返回的Person对象
        Person p = method();
//调用p对象中的show方法
        p.show();
    }

    //定义一个方法method，用来获取一个Person对象，在方法中完成Person对象的建立
    public static Person method(){
        Person p = new Person();
        return p;
    }
}

抽象类做为方法参数与返回值

抽象类做为方法参数

开发中，抽象类做为方法参数的状况也不少见。当遇到方法参数为抽象类类型时，要传入一个实现抽象类全部抽象方法的子类对象。以下代码演示：

//抽象类
abstract class Person{
    public abstract void show();
}
class Student extends Person{
    @Override
    public void show() {
        System.out.println("重写了show方法");
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
//经过多态的方式，建立一个Person类型的变量，而这个对象实际是Student
        Person p = new Student();
//调用method方法
        method(p);
    }

    //定义一个方法method，用来接收一个Person类型对象，在方法中调用Person对象的show方法
    public static void method(Person p){//抽象类做为参数
//经过p变量调用show方法,这时实际调用的是Student对象中的show方法
        p.show();
    }
}

抽象类做为方法返回值

抽象类做为方法返回值的状况，也是有的，这时须要返回一个实现抽象类全部抽象方法的子类对象。以下代码演示：

//抽象类
abstract class Person{
    public abstract void show();
}
class Student extends Person{
    @Override
    public void show() {
        System.out.println("重写了show方法");
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
//调用method方法，获取返回的Person对象
        Person p = method();
//经过p变量调用show方法,这时实际调用的是Student对象中的show方法
        p.show();
    }

    //定义一个方法method，用来获取一个Person对象，在方法中完成Person对象的建立
    public static Person method(){
        Person p = new Student();
        return p;
    }
}

接口做为方法参数与返回值

接口做为方法参数

接口做为方法参数的状况是很常见的，常常会碰到。当遇到方法参数为接口类型时，那么该方法要传入一个接口实现类对象。以下代码演示。

//接口
interface Smoke{
    public abstract void smoking();
}
class Student implements Smoke{
    @Override
    public void smoking() {
        System.out.println("课下吸口烟，胜过活神仙");
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
    //经过多态的方式，建立一个Smoke类型的变量，而这个对象实际是Student
        Smoke s = new Student();
        //调用method方法
        method(s);
    }

    //定义一个方法method，用来接收一个Smoke类型对象，在方法中调用Smoke对象的show方法
    public static void method(Smoke sm){//接口做为参数
    //经过sm变量调用smoking方法，这时实际调用的是Student对象中的smoking方法
        sm.smoking();
    }
}

接口做为方法返回值

接口做为方法返回值的状况，在后面的学习中会碰到。当遇到方法返回值是接口类型时，那么该方法须要返回一个接口实现类对象。以下代码演示。

//接口
interface Smoke{
    public abstract void smoking();
}
class Student implements Smoke{
    @Override
    public void smoking() {
        System.out.println("课下吸口烟，胜过活神仙");
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
//调用method方法，获取返回的会吸烟的对象
        Smoke s = method();
//经过s变量调用smoking方法,这时实际调用的是Student对象中的smoking方法
        s.smoking();
    }

 //定义一个方法method，用来获取一个具有吸烟功能的对象，并在方法中完成吸烟者的建立
    public static Smoke method(){
        Smoke sm = new Student();
        return sm;
    }
}

概括总结：

• 类做为方法参数时，说明要向方法中传入该类的对象
• 类做为方法返回值时，说明该方法要返回一个该类的对象。
• 抽象类做为方法参数时，说明要传入一个实现抽象类全部抽象方法的子类对象。
• 抽象类做为方法返回值时，说明须要返回一个实现抽象类全部抽象方法的子类对象。
• 接口做为方法参数时，说明该方法要传入一个接口实现类对象。
• 接口做为方法返回值时，说明该方法须要返回一个接口实现类对象。

经常使用API

Java 的API（API: Application(应用) Programming(程序) Interface(接口)）就是JDK中提供给咱们使用的类，这些类将底层的代码实现封装了起来，咱们不须要关心这些类是如何实现的，只须要学习这些类如何使用便可。

在JDK安装目录下有个src.zip文件，这个文件解压缩后里面的内容是全部Java类的源文件。能够在其中查看相对应的类的源码。
咱们在每次查看类中的方法时，都打开源代码进行查看，这种方式过于麻烦。其实，咱们能够经过查帮助文档的方式，来了解Java提供的API如何使用。以下图操做：查找Object类

 

经过帮助文档中类与方法的介绍，咱们就可以使用这个类了。

Object类

Object类是Java语言中的根类，即全部类的父类。全部类在建立对象的时候，最终找的父类就是Object。

equals方法

equals方法，用于比较两个对象是否相同，它其实就是使用两个对象的内存地址在比较。Object类中的equals方法内部使用的就是==比较运算符。
在开发中要比较两个对象是否相同，常常会根据对象中的属性值进行比较，也就是在开发常常须要子类重写equals方法根据对象的属性值进行比较。以下代码演示：

/*
描述人这个类，并定义功能根据年龄判断是不是同龄人
因为要根据指定类的属性进行比较，这时只要覆盖Object中的equals方法
在方法体中根据类的属性值进行比较
*/
class Person extends Object{
    int age ;
    //复写父类的equals方法，实现本身的比较方式
    public boolean equals(Object obj) {
//判断当前调用equals方法的对象和传递进来的对象是不是同一个
        if(this == obj){
            return true;
        }
//判断传递进来的对象是不是Person类型
        if(!(obj instanceof Person)){
            return false;
        }
//将obj向下转型为Perosn引用，访问其属性
        Person p = (Person)obj;
        return this.age == p.age;
    }
}

注意：在复写Object中的equals方法时，必定要注意public boolean equals(Object obj)的参数是Object类型，在调用对象的属性时，必定要进行类型转换，在转换以前必须进行类型判断。

toString方法

toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。
因为toString方法返回的结果是内存地址，而在开发中，常常须要按照对象的属性获得相应的字符串表现形式，所以也须要重写它。

class Person extends Object{
    int age ;
    //根据Person类的属性重写toString方法
    public String toString() {
        return "Person [age=" + age + "]";
    }
}

String类

查阅API中的String类的描述，发现String 类表明字符串。Java 程序中的全部字符串字面值（如 "abc" ）都做为此类的实例实现。

//演示字符串
String str = "AAA";
str = "BBB";

字符串是常量；它们的值在建立以后不能更改。也就是说一旦这个字符串肯定了，那么就会在内存区域中就生成了这个字符串。字符串自己不能改变，但str变量中记录的地址值是能够改变的。

字符串有大量的重载的构造方法。经过String类的构造方法能够完成字符串对象的建立，那么，经过使用双引号的方式建立对象与new的方式建立对象，有什么不一样呢？

String s3 = "abc";
String s4 = new String("abc");
System.out.println(s3==s4);//false
System.out.println(s3.equals(s4));//true,
////由于String重写了equals方法，创建了字符串本身的判断相同的依据（经过字符串对象中的字符来判断）

 s3和s4的建立方式有什么不一样呢？

s3建立，在内存中只有一个对象。这个对象在字符串常量池中
s4建立，在内存中有两个对象。一个new的对象在堆中，一个字符串自己对象，在字符串常量池中

String类构造方法

构造方法是用来完成String对象的建立，下图中给出了一部分构造方法须要在API中找到，并可以使用下列构造方法建立对象。

String s1 = new String(); //建立String对象，字符串中没有内容

byte[] bys = new byte[]{97,98,99,100};
String s2 = new String(bys); // 建立String对象，把数组元素做为字符串的内容
String s3 = new String(bys, 1, 3); //建立String对象，把一部分数组元素做为字符串的内容，参数offset为数组元素的起始索引位置，参数length为要几个元素

char[] chs = new char[]{’a’,’b’,’c’,’d’,’e’};
String s4 = new String(chs); //建立String对象，把数组元素做为字符串的内容
String s5 = new String(chs, 0, 3);//建立String对象，把一部分数组元素做为字符串的内容，参数offset为数组元素的起始索引位置，参数count为要几个元素

String s6 = new String(“abc”); //建立String对象，字符串内容为abc

String类的方法查找

String类中有不少的经常使用的方法，咱们在学习一个类的时候，不要盲目的把全部的方法尝试去使用一遍，这时咱们应该根据这个对象的特色分析这个对象应该具有那些功能，这样你们应用起来更方便。
字符串是一个对象，那么它的方法必然是围绕操做这个对象的数据而定义的。咱们想一想字符串中有哪些功能呢？
一、字符串中有多少个字符?

String str = "abcde";
int len = str.length();
System.out.println("len="+len);

二、获取部分字符串

String str = "abcde";
String s1 = str.substring(1); //返回一个新字符串，内容为指定位置开始到字符串末尾的全部字符
String s2 = str.substring(2, 4);//返回一个新字符串，内容为指定位置开始到指定位置结束全部字符
System.out.println("str="+str);
System.out.println("s1="+s1);
System.out.println("s2="+s2);

三、字符串是否以指定字符串开头。结尾同理

String str = "StringDemo.java";
boolean b1 = str.startsWith("Demo");//判断是否以给定字符串开头
boolean b2 = str.startsWith("String");
boolean b3 = str.endsWith("java");//判断是否以给定字符串结尾

四、字符串中是否包含另外一个字符串

String str = "abcde";
int index = str.indexOf(“bcd”); //判断是否包含指定字符串，包含则返回第一次出现该字符串的索引，不包含则返回-1
boolean b2 = str.contains("bcd");//判断是否包含指定字符串，包含返回true，不包含返回false

五、将字符串转成一个字符数组。或者字节数组

String str = "abcde";
char[] chs = str.toCharArray();
byte[] bytes = str.getBytes();

六、判断两个字符串中的内容是否相同

String str = "abcde";
String str2 = "abcde";
String str3 = "hello";
boolean b1 = str.equals(str2);
boolean b2 = str.equals(str3);

七、获取该字符串对象中的内容

String str = new String("hello");
System.out.println( str.toString() );
System.out.pintln( str );

直接打印引用类型变量时，默认调用该类型进行重写后的toString方法

下面的需求所对应的方法，本身动手在API中查找，并进行方法使用。

• 判断该字符串的内容是否为空的字符串
• 获取给定的字符，在该字符串中第一次出现的位置
• 获取该字符串中指定位置上的字符
• 把该字符串转换成 小写字符串
• 把该字符串转换成 大写字符串
• 在该字符串中，将给定的旧字符，用新字符替换
• 在该字符串中， 将给定的旧字符串，用新字符串替换
• 去除字符串两端空格，中间的不会去除，返回一个新字符串

StringBuffer类

在学习String类时，API中说字符串缓冲区支持可变的字符串，什么是字符串缓冲区呢？接下来咱们来研究下字符串缓冲区。
查阅StringBuffer的API，StringBuffer又称为可变字符序列，它是一个相似于 String 的字符串缓冲区，经过某些方法调用能够改变该序列的长度和内容。
原来StringBuffer是个字符串的缓冲区，即就是它是一个容器，容器中能够装不少字符串。而且可以对其中的字符串进行各类操做。

StringBuffer的方法使用

代码演示：
建立一个字符串缓冲区对象。用于存储数据。

StringBuffer sb = new StringBuffer();
sb.append("haha"); //添加字符串
sb.insert(2, "it");//在指定位置插入
sb.delete(1, 4);//删除
sb.replace(1, 4, "cast");//替换指定范围内的内容
String str = sb.toString();

注意：append、delete、insert、replace、reverse方法调用后，返回值都是当前对象本身，因此说，StringBuffer它能够改变字符序列的长度和内容。

StringBuffer类方法查找练习
下面的需求所对应的方法，本身动手在API中查找，并进行方法使用。

• 从指定位置开始，到末尾结束，截取该字符串缓冲区，返回新字符串
• 在原有字符串缓冲区内容基础上，删除指定位置上的字符

对象的方法链式调用

在咱们开发中，会遇到调用一个方法后，返回一个对象的状况。而后使用返回的对象继续调用方法。这种时候，咱们就能够把代码如今一块儿，如append方法同样，代码以下：

//建立一个字符串缓冲区对象。用于存储数据。
StringBuffer sb = new StringBuffer();
//添加数据。不断的添加数据后，要对缓冲区的最后的数据进行操做，必须转成字符串才能够。
String str = sb.append(true).append("hehe").toString();

不管多少数据，数据是什么类型都不重要，只要最终变成字符串就可使用StringBuffer这个容器。

StringBuilder类

查阅API发现还有一个StringBuilder类，它也是字符串缓冲区，StringBuilder与它和StringBuffer的有什么不一样呢？
咱们阅读StringBuilder的API说明发现，它也是一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用做 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种状况很广泛）。若是可能，建议优先采用该类，由于在大多数实现中，它比 StringBuffer 要快。

总结

一、Object: 它是全部类的超类，祖宗类。java中全部的类都直接或间接的继承这个类
方法：

• public String toString() 返回当前对象中的内容, 对于Object类默认操做来讲，返回的对象的类型+@+内存地址值
• public boolean equals(Object obj) 比较两个对象内容是否相同，对于Object类默认操做来讲,比较的是地址值

二、String: 字符串类，字符串是常量；它们的值在建立以后不能更改
方法：

• boolean equals(Object obj) 判断两个字符串中的内容是否相同
• boolean equalsIgnoreCase(String str) 判断两个字符串中的内容是否相同, 忽略大小写
• boolean contains(String str) 判断该字符串中 是否包含给定的字符串
• boolean startsWith(String str) 判断该字符串 是否以给定的字符串开头
• boolean endsWith(String str) 判断该字符串 是否以给定的字符串结尾
• boolean isEmpty() 判断该字符串的内容是否为空的字符串 ""
• int length() 获取该字符串的长度
• char charAt(int index) 获取该字符串中指定位置上的字符
• String substring(int start) 从指定位置开始，到末尾结束，截取该字符串，返回新字符串
• String substring(int start,int end) 从指定位置开始，到指定位置结束，截取该字符串，返回新字符串
• int indexOf(int ch ) 获取给定的字符，在该字符串中第一次出现的位置
• int indexOf(String str) 获取给定的字符串，在该字符串中第一次出现的位置
• int indexOf(int ch,int fromIndex) 从指定位置开始，获取给定的字符，在该字符
• byte[] getBytes() 把该字符串 转换成 字节数组
• char[] toCharArray() 把该字符串 转换成 字符数组
• String replace(char old,char new) 在该字符串中，将给定的旧字符，用新字符替换
• String replace(String old,String new) 在该字符串中， 将给定的旧字符串，用新字符串替换
• String trim() 去除字符串两端空格，中间的不会去除，返回一个新字符串
• String toLowerCase() 把该字符串转换成 小写字符串
• String toUpperCase() 把该字符串转换成 大写字符串
• int indexOf(String str,int fromIndex) 从指定位置开始，获取给定的字符串，在该字符串中第一次出现的位置

三、StringBuffer/StringBuilder:
方法：

• public StringBuffer append(String str) 在原有字符串缓冲区内容基础上，在末尾追加新数据
• public StringBuffer insert(int offset,String str) 在原有字符串缓冲区内容基础上，在指定位置插入新数据
• public StringBuffer deleteCharAt(int index) 在原有字符串缓冲区内容基础上，删除指定位置上的字符
• public StringBuffer delete(int start,int end) 在原有字符串缓冲区内容基础上，删除指定范围内的多个字符
• public StringBuffer replace(int start,int end,String str)在原有字符串缓冲区内容基础上，将指定范围内的多个字符 用给定的字符串替换
• public StringBuffer reverse() 将字符串缓冲区的内容 反转 "abc"----"cba"
• public String substring(int start) 从指定位置开始，到末尾结束，截取该字符串缓冲区，返回新字符串
• public String substring(int start,int end) 从指定位置开始，到指定位置结束，截取该字符串缓冲区，返回新字符串