java基础（六）

发表于 | 分类于 | | 本文总阅读量 次
字数统计: 1.6k 字 | 阅读时长 ≈ 6 分钟

这次主要记录抽象类、接口和String的其它学习。

抽象类

什么是抽象类呢？定义一个类，我们可以不必完全实现它里面的功能，这就是抽象类。没有具体的方法，就是抽象。

下面是具体的使用。

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
abstract class Animal						//定义一个抽象类animal
{
	String color;						//抽象类里可以有属性
	
	public Animal(String color) {				//也有构造方法
		this.color = color;
	}
								//抽象类有抽象方法，修饰符都是abstract
	abstract void sound();					//抽象方法可以protected、public、default修饰
	protected abstract void nose();
	public abstract void eyes();
	
	public void leg()					//抽象类也可以实现普通方法
	{
		System.out.println("短腿");
	}
	

	/*
	abstract String skinColor()				//抽象方法不能在抽象类实现
	{
		return color;
	}
	final abstract void high();				//抽象方法要能够被子类继承和实现
	private  abstract void hair();
	static abstract void weight();
	*/
}

因为抽象类很多方法并未实现，我们也不能new一个抽象类的对象。不能凭空产生一个方法。
要想使用抽象类的方法，我们只能继承，如果子类也不能全实现抽象类的方法，那子类也必须是抽象类，直到能全实现方法的子类，我们新建对象。

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
41
42
43
44
45
46
47
48
49
50
51
52
53
public class abstractTest {

	public static void main(String[] args) {
		Animal cat = new Cat("白色");
		System.out.println(cat.color);			//打印 白色
		cat.eyes();					//打印 蓝眼睛
		cat.leg();					//打印 短腿
	}
}

abstract class Animal						//定义一个抽象类animal
{
	String color;						//抽象类里可以有属性
	
	public Animal(String color) {				//也有构造方法
		this.color = color;
	}
								//抽象类有抽象方法，修饰符都是abstract
	abstract void sound();					//抽象方法可以protected、public、default修饰
	protected abstract void nose();
	public abstract void eyes();
	
	public void leg()					//抽象类也可以实现普通方法
	{
		System.out.println("短腿");
	}
}

abstract class Felidae extends Animal				//Felidae并没有实现Animal全部方法，只能定义为抽象类
{

	public Felidae(String color) {
		super(color);
	}
	void sound()
	{
		System.out.println("喵喵喵~~~");
	}
}
class Cat extends Felidae					//Cat实现全部方法
{
	public Cat(String color) {
		super(color);
	}
	protected void nose()
	{
		System.out.println("鼻子");
	}
	public void eyes()
	{
		System.out.println("蓝眼睛");
	}
}

接口

接口和抽象类差不多，但是，比抽象类更规范。
它不实现任何方法，它的一般只有常量和抽象方法。

1
2
3
4
5
6
7
8
9
10
11
12
interface Car
{
	public static final int LENGTH = 280;					//定义一个常量
	/*public final static*/ int WIDTH = 120;			
	public abstract void sound();						//抽象方法
	/*public abstract*/ void weigth();
	static void xx()							//静态方法，好像不推荐使用
	{
		System.out.println("--------");
		
	}
}

下面是例子。

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
public class Test {
	public static void main(String[] args) {
		Sedan c = new Sedan();
		c.sound();							//打印 滴滴滴！！！
		c.weigth();							//打印 it
		System.out.println(c.LENGTH);					//打印 280
		Car.xx();							//打印 --------
		c.color();							//打印 白色
		c.feel();							//打印 舒服
	}
	
}

interface Car
{
	public static final int LENGTH = 280;					//定义一个常量
	/*public final static*/ int WIDTH = 120;			
	public abstract void sound();						//抽象方法
	/*public abstract*/ void weigth();
	static void xx()							//静态方法，好像不推荐使用
	{
		System.out.println("--------");
		
	}
}

interface InterF
{
	void feel();
}

abstract class CarStyle
{
	abstract void color();
}

class Sedan extends CarStyle implements Car,InterF				//继承只能单继承，但接口可以多继承，接口实现用implements
{
	@Override								//表明实现的方法，一般编译器在快捷键输入会自动帮忙生成	
	public void sound() {
		System.out.println("滴滴滴！！！");
		
	}
	@Override
	public void weigth() {
		System.out.println("1t");
		
	}

	public void feel(){
		System.out.println("舒服");
	}
	@Override
	void color(){
		System.out.println("白色");
	}
}

抽象类和接口的共同点:
1、都有抽象方法。
2、都需要被子类继承。

抽象类和接口的不同点:
1、抽象类的变量只是普通变量，接口是常量。
2、抽象类可以有具体的方法。
3、接口相比抽象类讲，定义的是一种规范。
4、接口可以多继承。

String

String是不可变的引用类型。使用的时候总会产生很多新的对象，所以就有了StringBuffer和StringBuilder两个类，它们都是继承于AbstractStringBuilder这个抽象类，而都现实了父类的方法，所以它们相当于双胞胎兄弟。

而双胞胎也有差别，它们的差别就是线程是否安全。

StringBuider下实现append()方法

1
2
3
4
@Override
public StringBuilder append(Object obj) {
    return append(String.valueOf(obj));
}

StringBuffer下实现append()方法

1
2
3
4
5
public synchronized StringBuffer append(Object obj) {
    toStringCache = null;
    super.append(String.valueOf(obj));
    return this;
}

看得出来，区别不是很大，只是在StringBuffer下，方法都多了一个synchronized修饰符，该修饰符保证线程安全。

线程安全解决啥呢。大致就是我们使用电脑时，不是一个只运行一个软件，而是很多个在同时运行，这时有多个软件修改了一个文件内容和多个软件同时获取该文件内容，在同一时间下，就可能出现错误。所以要保证线程安全，一个一个来，慢慢校验。所以线程安全提供了安全性，但效率会降低。

而StringBuider和StringBuffer方法都差不多一样，所以了解其中一个就行，以Stringbuider为例。

方法名 使用说明
append(Object) 实现多个字符串拼接，可以为任意类型
delete(int, int) 删除起始位置到终止位置(不包括终止位置)之间的元素
deletCharAt(int) 删除该下标的元素
replce(int, int, String 把起始位置到终止位置(不包括终止位置)之间的元素修改为新的字符串
insert(int, Object) 在该下标插入某个元素 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static void main(String[] args) {
	StringBuilder str = new StringBuilder();
	str.append("a");			//拼接任意元素，"a",12,1.2到str
	str.append(12);
	str.append(1.2);
	System.out.println(str);		//打印 a121.2
	
	str.delete(3,5);			//删除从3到5之间的元素[3,5)
	System.out.println(str);		//打印 a122
	
	str.deleteCharAt(0);			// 删除下标为0的元素
	System.out.println(str);		//打印 122
	
	str.replace(1, 2, "java");		//下标[1,2)变换为"java" 	
	System.out.println(str);		//打印 1java2
	
	str.insert(1, "hello");			//在下标为1处插入字符串"hello"
	System.out.println(str);		//打印 1hellojava2
	str.insert(0, true);			//在下标为0处插入布尔值true
	System.out.println(str);		//打印 true1hellojava2
}

这是都是StringBuider常用的方法，当然还有indexOf()、lastIndexOf()这样的字符匹配，length()长度，equals()比较内容等等，这些以前也用过的方法。

谢谢您对我的支持
0%