java学习（含字符串、多态、抽象类、内部类）

java学习（含字符串、多态、抽象类、内部类）

字符串比较是否相同

• equals() 方法 ：该方法的作用是判断两个字符串对象的内容是否相同。如果相同则返回 true，否则返回 false。
• 忽略大小写，比如：java 和 Java 是一样的，那怎么办呢？可以调用 equalsIgnoreCase() 方法，其用法与 equals() 一致，不过它会忽视大小写。
• 使用 “==” 比较的是两个对象在内存中存储的地址是否一样。如：

         String s1 = "abc";
         String s2 = new String("abc");
         boolean b = (s1 == s2);
1
2
3

其结果变量 b 的值是 false，因为 s1 对象对应的地址是 “abc” 的地址，而 s2 使用 new 关键字申请新的内存，所以内存地址和 s1 的 “abc” 的地址不一样，所以获得的值是 false。

字符串连接

• 使用 +，比如 String s = "Hello " + “World!”。（使用 + 进行连接，不仅可以连接字符串，也可以连接其他类型。但是要求进行连接时至少有一个参与连接的内容是字符串类型。）
• 使用 String 类的 concat() 方法。

字符串索引（字符提取）

charAt() 方法 ：作用是按照索引值（规定字符串中第一个字符的索引值是 0，第二个字符的索引值是 1，依次类推），获得字符串中的指定字符。例如：

String s = "abc";
char c = s.charAt(1);
copy
1
2
3

则变量 c 的值是 ‘b’。

indexOf(char ch) 返回值为int类型，搜索字符 ch 第一次出现的索引
indexOf(String value) 返回值为int类型，搜索字符串 value 第一次出现的索引
lastIndexOf(char ch) 返回值为int类型，搜索字符 ch 最后一次出现的索引
lastIndexOf(String value) 返回值为int类型，搜索字符串 value 最后一次出现的索引
substring(int index) 返回值为String类型，提取从位置索引开始到结束的字符串
substring(int beginindex, int endindex) 返回值为String类型，提取 beginindex 和 endindex 之间的字符串部分
trim() 返回值为String类型，返回一个前后不含任何空格的调用字符串的副本

删除指定索引字符

delete（int a,int b） 有两个参数，使用时删除索引从a开始（包含a）到b（不包含b）的所有字符；

deleteCharAt（int a） 只有一个参数，使用时删除索引为a的字符；

String、StringBuffer和StringBuilder的区别：

• String类是不可变类，即一旦一个String对象被创建以后，包含在这个对象中的字符序列是不可改变的，直至这个对象被销毁。
• StringBuffer对象则代表一个字符序列可变的字符串，当一个StringBuffer被创建以后，通过StringBuffer提供的append()、insert()、reverse()、setCharAt()、setLength()等方法可以改变这个字符串对象的字符序列。一旦通过StringBuffer生成了最终想要的字符串，就可以调用它的toString()方法将其转换为一个String对象。
• StringBuilder类也代表可变字符串对象。实际上，StringBuilder和StringBuffer基本相似，两个类的构造器和方法也基本相同。不同的是：StringBuffer是线程安全的，而StringBuilder则没有实现线程安全功能，所以性能略高。

类型变量

• 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
• 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
• 类变量：也叫静态变量，类变量也声明在类中，方法体之外，但必须声明为 static 类型。

构造方法

创建一个对象的时候，至少调用一个构造方法。比如在新建一个对象 new Object()，括号中没有任何参数，代表调用一个无参构造方法（默认构造方法就是一个无参构造方法）。构造方法的名称必须与类名相同，一个类可以定义多个构造方法。

封装

隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别

如何去实现类的封装呢？

• 修改属性的可见性，在属性的前面添加修饰符 (private)
• 对每个值属性提供对外的公共方法访问，如创建getter/setter（取值和赋值）方法用于对私有属性的访问
• 在 getter/setter方法里加入属性的控制语句，例如我们可以加一个判断语句，对于非法输入给予否定。

多态

允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。多态也称作动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
多态的实现条件：三个必要条件分别为继承、重写和向上转型（即父类引用指向子类对象）
多态的实现方式：继承父类进行方法重写，抽象类和抽象方法，接口实现。

抽象类

定义类时，前面加上 abstract 关键字修饰的类叫抽象类。

何时用抽象类：

• 在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。也就是说抽象类是约束子类必须要实现哪些方法，而并不关注方法如何去实现。
• 从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性

抽象类如何用代码实现呢：

• 用 abstract 修饰符定义抽象类。
• 用 abstract 修饰符定义抽象方法，只用声明，不需要实现。
• 包含抽象方法的类就是抽象类。
• 抽象类中可以包含普通的方法，也可以没有抽象方法。
• 抽象类的对象不能直接创建，通常是定义引用变量指向子类对象。
  实现代码如下：

TetePhone.java
public abstract class TelePhone {

	public abstract void  call();
	public abstract void message();
}
1
2
3
4
5
6

CellPhone.java
public class CellPhone extends TelePhone {

	@Override
	public void call() {
		// TODO Auto-generated method stub
		System.out.println("我要打电话！");
	}

	@Override
	public void message() {
		// TODO Auto-generated method stub
		System.out.println("我要发短信！");
	}
	public static void main(String[] args) {
		CellPhone ce=new CellPhone();
		ce.call();
		ce.message();
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

接口

用于描述类所具有的功能，而不提供功能的实现，功能的实现需要写在实现接口的类中，并且该类必须实现接口中所有的未实现方法。

实现代码：

interface Animal{
		int y=5;
		public void eat();
		public void travel();
	}
1
2
3
4
5

public class Cat implements Animal {

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("猫在吃东西！");
	}

	@Override
	public void travel() {
		// TODO Auto-generated method stub
		System.out.println("猫在玩耍！");
	}
	public static void main(String[] args) {
		Cat cat=new Cat();
		cat.eat();
		cat.travel();
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

内部类

将一个类的定义放在另一个类的定义内部，这就是内部类。而包含内部类的类被称为外部类。

内部类的主要作用如下：

• 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
• 内部类的方法可以直接访问外部类的所有数据，包括私有的数据
• 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便
• 内部类允许继承多个非接口类型

成员内部类的使用方法：

• Student 类相当于 People 类的一个成员变量，所以 Student 类可以使用任意访问修饰符。
• Student 类在 People 类里，所以访问范围在类里的所有方法均可以访问 People 的属性（即内部类里可以直接访问外部类的方法和属性，反之不行）。
• 定义成员内部类后，必须使用外部类对象来创建内部类对象，即内部类 对象名 = 外部类对象.new 内部类();。
• 如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this关键字。如上述代码中：a.this。

// People.java
//外部类People
public class People {
    private String name = "LiLei";         //外部类的私有属性
    //内部类Student
    public class Student {
        String ID = "20151234";               //内部类的成员属性
        //内部类的方法
        public void stuInfo(){
            System.out.println("访问外部类中的name：" + name);
            System.out.println("访问内部类中的ID：" + ID);
        }
    }

    //测试成员内部类
    public static void main(String[] args) {
        People a = new People();     //创建外部类对象，对象名为a
        Student b = a.new Student(); //使用外部类对象创建内部类对象，对象名为b
        // 或者为 People.Student b = a.new Student();
        b.stuInfo();   //调用内部对象的suInfo方法
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

静态内部类是 static 修饰的内部类，这种内部类的特点是：

• 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员的方式访问。
• 如果外部类的静态成员与内部类的成员名称相同，可通过 类名.静态成员访问外部类的静态成员；
• 如果外部类的静态成员与内部类的成员名称不相同，则可通过 成员名 直接调用外部类的静态成员。
• 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名 = new 内部类();。

// People.java
//外部类People
public class People {
    private String name = "LiLei";         //外部类的私有属性

/*外部类的静态变量。
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。
*/
    static String ID = "510xxx199X0724XXXX";

    //静态内部类Student
    public static class Student {
        String ID = "20151234";               //内部类的成员属性
        //内部类的方法
        public void stuInfo(){
            System.out.println("访问外部类中的name：" + (new People().name));
            System.out.println("访问外部类中的ID：" + People.ID);
            System.out.println("访问内部类中的ID：" + ID);
        }
    }

    //测试成员内部类
    public static void main(String[] args) {
        Student b = new Student();   //直接创建内部类对象，对象名为b
        b.stuInfo();                 //调用内部对象的suInfo方法
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

局部内部类

指内部类定义在方法和作用域内。局部内部类也像别的类一样进行编译，但只是作用域不同而已，只在该方法或条件的作用域内才能使用，退出这些作用域后无法引用的。

// People.java
//外部类People
public class People {
    //定义在外部类中的方法内：
    public void peopleInfo() {
        final String sex = "man";  //外部类方法中的常量
        class Student {
            String ID = "20151234"; //内部类中的常量
            public void print() {
                System.out.println("访问外部类的方法中的常量sex：" + sex);
                System.out.println("访问内部类中的变量ID:" + ID);
            }
        }
        Student a = new Student();  //创建方法内部类的对象
        a.print();//调用内部类的方法
    }
    //定义在外部类中的作用域内
    public void peopleInfo2(boolean b) {
        if(b){
            final String sex = "man";  //外部类方法中的常量
            class Student {
                String ID = "20151234"; //内部类中的常量
                public void print() {
                    System.out.println("访问外部类的方法中的常量sex：" + sex);
                    System.out.println("访问内部类中的变量ID:" + ID);
                }
            }
            Student a = new Student();  //创建方法内部类的对象
            a.print();//调用内部类的方法
        }
    }
    //测试方法内部类
    public static void main(String[] args) {
        People b = new People(); //创建外部类的对象
        System.out.println("定义在方法内：===========");
        b.peopleInfo();  //调用外部类的方法
        System.out.println("定义在作用域内：===========");
        b.peopleInfo2(true);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

结果显示为：

$ javac People.java
$ java People
定义在方法内：===========
访问外部类的方法中的常量sex：man
访问内部类中的变量ID:20151234
定义在作用域内：===========
访问外部类的方法中的常量sex：man
访问内部类中的变量ID:20151234
1
2
3
4
5
6
7
8

匿名内部类

顾名思义，就是没有名字的内部类。正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口。
匿名内部类是不能加访问修饰符的。要注意的是，new 匿名类，这个类是要先定义的, 如果不先定义，编译时会报错该类找不到。

package Method;

public class Outer {

	public Inner getInner(final String name,String city){
		return new Inner(){
			private String nameStr=name;
			public String getName(){
				return nameStr;
			}
		};
		
	}
	
	interface Inner{
		String getName();
	}
	public static void main(String[] args) {
		Outer outer=new Outer();
		Inner inner=outer.getInner("Inner", "NerYork");
		System.out.println(inner.getName());
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

结果显示为：

Inner
1