Java基础

发表于 | 更新于 | 分类于 ， | 阅读次数：
本文字数： 6.9k | 阅读时长 ≈ 6 分钟

一.八种基本数据类型

1
2
3
4
5
6
7
8
byte // 8位 默认值为0 1个字节
short // 16位 默认0
   int // 32位 默认0 4个字节
   long // 64位 默认0L
   float // 32位 默认0.0F
   double // 64位 默认0.0D
   char // 16位 默认 空
   boolean // 8位 默认 false

二.String-字符串

1.String

字符串不变; 它们的值在创建后不能被更改。 字符串缓冲区(StringBuffer,StringBuilder)支持可变字符串。 因为String对象是不可变的，它们可以被共享

传递null参数到此类中的构造函数或方法将导致抛出NullPointerException 。

1
2
3
4
 String str = "abc";
// 相当于
 char data[] = {'a', 'b', 'c'};
 String str = new String(data);

  1. compareTo

    1
    2
    public int compareTo(String anotherString)
    //按字典顺序比较两个字符串。 比较是基于字符串中每个字符的Unicode值

  2. isEmpty()

    1
    2
    public boolean isEmpty()
    //true如果，只有 length()是 0 。

  3. 切割字符串

    1. split()

      1
      2
      public String[] split(String regex)
      //该方法的工作原理是通过使用给定表达式和限制参数为零调用双参数split方法。 因此，尾随的空字符串不会包含在结果数组中。

    2. substring()

      1
      2
      public String substring(int beginIndex)
      //返回一个字符串，该字符串是此字符串的子字符串

    3. charAt()

      1
      2
      public char charAt(int index)
      //返回char指定索引处的值。 指数范围为0至length() - 1 。 该序列的第一个char值在索引0 ，下一个索引为1 ，依此类推，与数组索引一样。

2.StringBuffer

一个可变的字符序列

线程不安全

在可能的情况下，建议使用这个类别优先于StringBuilder ，因为它在大多数实现中将更快。

将null参数传递给null中的构造函数或方法将导致抛出NullPointerException

3.StringBuilder

可变的字符序列

线程安全

将null参数传递给null中的构造函数或方法将导致抛出NullPointerException

三.位运算

与（&）、非（~）、或（|）、异或（^）

1.与 &

两个操作数中位都为1，结果才为1，否则结果为0

2.非 ~

如果位为0，结果是1，如果位为1，结果是0

3.或 |

两个位只要有一个为1，那么结果就是1，否则就为0

4.异或 ^

两个操作数的位中，相同则结果为0，不同则结果为1

5.十进制-二进制

二进制: 0 1

1 1 1 1 1 1 1 1 二进制
128 64 32 16 8 4 2 1 十进制

十进制整数转换成二进制采用“除2倒取余”，十进制小数转换成二进制小数采用“乘2取整”。

6.十进制-八进制

八进制：它的基数是8，总共有8个数字符号(0，1，2，3，4，5，6，7)，

十进制整数转换成八进制采用“除8倒取余”，十进制小数转换成二进制小数采用“乘8取整”。

7.十进制-十六进制

十六进制：它的基数是16，总共有16个数字符号(0，1，2，3，4，5，6，7，8，9，

​ A[表示10]，B[表示11]，C[表示12]，D[表示13]，E[表示14]，F[表示15])，

十进制整数转换成十六进制采用“除16倒取余”，十进制小数转换成十六进制小数采用“乘16取整”。

8.二进制-八进制-十六进制

为什么有八进制,十六进制?因为其是2的倍数,方便运算 因为8=2^3^ 16=2^4^

二进制-八进制

二进制转换成八进制的时候，只要将二进制的表示从右往左开始，每三位二进制数为1组

八进制转换为二进制只需要将八进制的每一个数用三位二进制表示，然后相连既可以。

二进制(0011 0101)B转换为八进制
第一组:101 第二组:011 第三组:00
第一组计算过程是:1 2^0^+0 2^1^+1 2^2^=5；
第二组计算过程是:0 2^0^+1 2^1^+1 2^2^=6；
所以最后的结果是65。也就是用6和5直接相连，而不是相加，这里还要注意一下相连的顺序问题，是6–5的方向。

二进制-十六进制
二进制转换为十六进制就是将二进制每四位二进制为一组

十六进制转换为二进制只要需要将十六进制的每一个数用四位二进制表示，然后相连即可。

四.接口

接口（Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合

一个类只由抽象方法和全局常量组成

1.很干净的接口

1
2
3
public interface TestInterface {

}

2.概念而言,接口可以放的东西

JDK 1.8 以后，接口里可以有静态方法和方法体了

1
2
3
4
5
6
7
8
9
10
11
12
13
public interface TestInterface {
	// 全局变量
	public static final String NAME = "ZHOU";
	// 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract
	//（只能是 public abstract，其他修饰符都会报错）
	public String SIX = "";

	// 方法
	public abstract int getData();
	//接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量
	//（并且只能是 public，用 private 修饰会报编译错误）。
	int getDataa();
}

但是,也可以放普通内部类,抽象内部类,内部接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public interface TestInterface {
	// 全局变量
	public static final String NAME = "ZHOU";
	// 方法
	public abstract int getData();
	// 普通内部类
	class AA{}
	// 抽象内部类
	abstract class BB{}
	// 内部接口
	interface CC {}
	// 外部接口
	static interface DD{}
}

3.接口与类的区别

  • 不能实例化对象
  • 没有构造方法
  • 方法必须是抽象方法
  • 只有用 static 和 final修饰的变量
  • 不能被继承,而是要被类实现
  • 支持多继承

4.接口的应用

1.Factory工厂设计模式

使用工厂设计模式，解耦

1
2
3
4
5
6
7
8
> // 没有使用工厂模式 
> public static void main(String[] args) {
>      //Fruit f = new Apple();
>      Fruit f = new Orange();
>      f.eat();
> 
>  }
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
> // 创建工厂类
> class Factory{
>  public static Fruit getInstance(String className){
>      if("apple".equals(className)){
>          return new Apple();
>      }else if("orange".equals(className)){
>          return new Orange();
>      }else{
>          return null;
>      }
> 
>  }
> }
> // 使用工厂模式
> public static void main(String[] args) {
>      Fruit f = Factory.getInstance("apple");
>      f.eat();
> 
>  }
>

2.Proxy代理设计模式

代理模式是对象的结构模式。代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。

使用代理模式，可以将功能划分的更加清晰，有助于后期维护！

  1. 抽象对象角色
  2. 目标对象角色
  3. 代理对象角色
1
2
3
4
// 抽象对象角色
public interface SourceObj {
    public void doSomethings();
}
1
2
3
4
5
6
7
8
// 目标对象角色
public class RealObj implements SourceObj{

    @Override
    public void doSomethings() {
        System.out.println("do somethings");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 代理对象角色
public class ProxyObj implements SourceObj{

    //创建目标对象
    RealObj realObj = new RealObj();

    @Override
    public void doSomethings() {
        // 添加新的方法
        System.out.println("before do somethings");
        
        realObj.doSomethings(); 
        
        // 添加新的方法
        System.out.println("end do somethings");
    }
}

五.抽象方法

1.定义抽象类

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

抽象类定义：

1.抽象方法必须为 public 或 protected,

2.不能被实例化，采用向上转型处理

3.必须有子类 一个子类只能继承一个抽象类

4.子类不是抽象方法，则需要全部重写父类的抽象方法

1
2
3
4
5
6
7
8
9
10
11
12
public abstract class C {
    //构造方法
    public C(){
		System.out.println("C类的构造方法");
	}
	//普遍方法
	public void a() {
		System.out.println("有方法体");
	}
	// 抽象方法
	public abstract void b();
}

有构造方法，总是先执行父类的构造，再去执行子类的构造方法

1
2
3
4
5
6
7
8
9
10
11
public class D extends C {
	// 构造方法
	public D() {
		System.out.println("D类的构造方法");
	}

	@Override
	public void b() {
		System.out.println("d-c.b");
	}
}
1
2
3
4
public static void StringTest() {
	D d = new D();
	d.b();
}

结果：总是先执行父类的构造，再去执行子类的构造方法
C类的构造方法
D类的构造方法
d-c.b

允许内部抽象类 使用static声明外部抽象类

1
2
3
4
5
6
abstract class A{//定义一个抽象类 这里不允许使用static声明
	
	static abstract class B{//static定义的内部类属于外部类
		public abstract void print();
	}
}

2.抽象类的应用

Template 模板设计模式

模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。 这种类型的设计模式属于行为型模式。定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。

模板模式主要由抽象模板(Abstract Template)角色和具体模板(Concrete Template)角色组成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 抽象模板角色
abstract class  Game{
	
	//启动游戏
	protected abstract void  runGame();
	//结束游戏
	protected abstract void endPlayGame();
	
	//模板方法
	public final void play() {
		runGame();
		endPlayGame();
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
// 具体模板角色
class ContraGame extends Game{

   @Override
   protected void runGame() {
   	System.out.println("启动aa游戏...");
   }
    
   @Override
   protected void endPlayGame() {
   	System.out.println("角色死亡，aa游戏结束！");
   }
}
1
2
3
4
5
6
//测试
public static void main(String[] args) {
   	Game game = new ContraGame();
   	game.play();
   	System.out.println();
}

结果：

启动aa游戏…

角色死亡，aa游戏结束！

优点

扩展性好，对不变的代码进行封装，对可变的进行扩展；
可维护性好，因为将公共代码进行了提取，使用的时候直接调用即可；

缺点

因为每一个不同的实现都需要一个子类来实现，导致类的个数增加，会使系统变得复杂；

使用场景

有多个子类共有逻辑相同的方法；
重要的、复杂的方法，可以考虑作为模板方法。

注意事项

为防止恶意操作，一般模板方法都加上 final 关键词！防止修改

六.重写与重载

1.区别

区别 重写 重载
1 英文 Override OverLoading
2 定义 方法名相同，参数类型及参数个数不同， 方法名，参数类型，参数个数，返回值完全相同
3 权限 没有权限要求 子类的重写父类的方法，该方法不能拥有比父类更严格的访问控制权限
4 范围 发生在一个类中 发生在继承关系类中

2.this与super

区别 this super
1 定义 表示本类对象 表示父类对象
2 使用 this.属性，this.方法，this(); super.属性，super.方法(),super()
3 构造方法 放在首行 放在首行
4 查找范围 先从本类查找，找不到去父类找 直接找父类
5 特殊 表示当前对象

小唠嗑：

本章到这里就结束了，谢谢耐心看到这里的各位Boss,如果觉得有哪里说的不好的地方，还请高抬贵手多多原谅，不惜指教。

最后，谢谢！

---本文结束感谢您的阅读!---