Java基础复习

Java基本语言特性

常量、变量、枚举、数组

  • 常量常量表示程序运行过程中不能改变的值

1.用于代表常数,便于程序的修改
比如,在程序最开始的地方定义一个

1
2
3
4
5
6
final PI = 3.14159
public static void main(String args[]){
float r = 10.0;
float s = PI*r*r/2;
}

然后,后期需要更改这个值的时候,就可以直接修改PI的值了;而不用一个一个的去修改

2.增强程序可读性

3.常量可以先声明,后赋值;但是只能赋值一次

1
2
final PI;
PI = 3.14159;

  • 变量变量表示程序的状态;程序通过改变变量的值来改变整个程序的状态;

(书上看的)
其实感觉没这么邪乎吧,就是在程序运行中可以被改变的值;用来实现一些逻辑;

1
int a = 10;

声明方式: 数据类型 变量名称;

通过“=”号赋值,“==”好代表是否相等;


  • 枚举
    枚举是一种类型;只能够赋enum中规定的值;
1
2
3
4
5
6
7
8
9
public enum Color{
RED,GREEN,BLUE ;
};
public class Main{
public static void main(String args[]){
Color c = Color.BLUE;
}
}

以上是基本用法;

然后枚举有几种用法如下:

1.在switch中使用

2.直接充当常量使用

3.向枚举中添加新方法

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
public enum Color{
RED("red", 1), GREEN("green",2);
private String name;
private int index;
private Color(String name, int index){
this.name = name;
this.index = index;
}
public static String getName(int index){
for(Color c : Color.values()){
if(c.getIndex()==index){
return c.name;
}
}
}
// get set 方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
}

4.覆盖枚举的方法

1
2
3
4
5
6
7
8
9
public enum Color{
...
...
@Override
public String toString(){
...
}
}

5.实现接口
枚举继承java.lang.Enum类;
所以只能继承接口了;

6.使用接口组织枚举


  • 数组Array 相同类型数据的集合

定义数组

1.方式1:type[] xxx = new type[sum];

2.方式2:type xxx[] = new type[sum];

3.方式3:定义的时候直接初始化 type[] xxx = new type[]{x,x,x,x};

或者:type[] 变量名 = {x,x,x,x};

运用

1.xxx[index];通过索引访问元素

2.xxx.length:获取数组长度

3.数组元素不为基本原生数据类型时,存放的是引用类型,而不是对象本身
当生成对象之后,引用才指向对象,否则引用为null。

二维数组

type[][] xxx = new type[sum][sum];
type xxx[][] = new type[sum][sum];

其中,声明的二维数组,可以让第二维的数组不等长;

1
2
3
int[][] a = new int[3][];
a[0] = new int[3];
a[1] = new int[5];

Object与数据类型

  • Object对象时所有对象的顶级父类

以下记录一些常用方法

  1. equals(Object obj)
  2. finalize()
  3. getClass
  4. hashCode()
  5. notify
  6. notifyAll();
  7. wait()
  8. Clone()
  9. toString()
  • 数据类型
基本数据类型 封装器类 位数
boolean Boolean 1
byte Byte 8
short Short 16
int Integer 32
long Long 64
float Float 32
double Double 64
void Void

字符串

字符串主要有三种表现形式吧;
String,StringBuilder,StringBuffer;

String是不可变对象;StringBuilder和StringBuffer是可变对象

String的字符串操作,如value+“abd”;时,会返回一个String对象,但不会是原来的value发生改变;

通过,观察其运行时的情况,会发现,String对象执行字符串变换操作如+时,是将String对象转为StringBuilder再合并成新的String返回的;

String对象是不可变的,故是线程安全的;而StringBuffer在方法中加了同步锁或者对调用的方法加了同步锁,故事线程安全的;
而StringBuilder是线程不安全的;

基本运算

算术运算符

“+” 加
“-” 减
“*” 乘
“/” 除
“%” 模运算(取余)
“++” 自加1
“–” 自减1

关系运算符

“==” 相等
“!=” 不相等
“>” 大于
“<” 小于
“>=” 大于等于
“<=” 小于等于

位运算符

“&” 按位与
“|” 按位或
“^” 异或运算
“~” 求非
“>>” 右移;其中最高位取1或0看二进制表示的最高位
“<<” 左移
“>>>” 无符号右移,忽略符号位,空位都以0补齐

逻辑运算符

“&&” 并且
“||” 或者
“!” 非

赋值运算符

“=”
“+=”
“-=”
“*=”
“%=”
“<<=”
“>>=”
“&=”
“^=”
“!=”

其它运算符

1.(?:)条件运算符

2.instanceof运算符(这个操作符只用于对象引用变量。操作检查对象是否为特定类型(类类型或接口类型))

常用逻辑控制

if语句

1
2
3
4
5
6
7
if(){
}else if(){
}else{
}

循环语句

1.for(,,)语句;

1
2
3
for(int i = 0 ; i < sum ; i++){
}

2.while语句;

1
2
3
4
5
6
7
while(boolean){
}
do{
}while()

switch语句

1
2
3
4
5
6
7
8
9
10
switch(){
case xxx :
...
break;
case xxx :
...
break;
default :
break;
}

面向对象程序

面向对象程序设计概述

Object-oriented programming (OOP) 是一种基于对象的编程思维;
我们将问题空间中的元素和在方案空间的表示物称作“对象”(Object)

这里我理解为,像现实生活一样,我们把我们利用计算机解决问题时的所有东西都作为对象;万物皆对象;

而对象和对象也有共通的地方,所有属性和动作一样的对象就属于同个类;
例如,汽车有四个轮子,有颜色,名字,其行为有前进后退、加速等;

软件世界中的对象和现实世界中的对象类似,对象存储状态在字段(field)里,而通过方法(methods)暴露其行为。方法对对象的内部状态进行操作,并作为对象与对象之间通信主要机制。隐藏对象内部状态,通过方法进行所有的交互,这个面向对象编程的一个基本原则——数据封装(data encapsulation)。

程序是一大堆对象的组合;对象和对象间通过消息传递告知自己需要做什么;

面向对象程序设计有四个特性:封装、抽象、继承、多态

类(class)基本概念

类是一个模板,它描述一类对象的行为和状态。

类利用class定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Dog{
String bread;
int age;
String color;
void barking(){
...
}
void hungry(){
...
}
void sleeping(){
...
}
}

以上是菜鸟教程中的一个例子;不过我觉得方法名命名得不太好,像是某种状态,而不是某个动作;


一个类可以包括:局部变量,成员变量,类变量;

局部变量就是方法和构造方法的或者语句块中定义的变量;只在局部有效;

语句块指的应该是static{},或者{}代码块

成员变量定义在类中,在创建对象时被实例化,成员变量可以被类中的方法、构造方法和特定类的语句块访问;

类变量被声明为static类型的变量,声明在类中、方法体外,可以直接通过类名调用;


构造方法:每个类都有构造方法,如果没有显式的定义构造方法,Java编译器会提供一个默认的;

1
2
3
4
5
public class Puppy{
public Puppy(){
}
}

对象

对象是类的一个实例,有状态和行为

创建对象需要三步:

声明:声明一个对象,包括对象名称和对象类型

实例化:使用new来创建一个对象

初始化:使用new创建一个对象时,会调用构造方法初始化对象

方法参数

基本类型作为参数传递时,是传递值的拷贝

而对象作为参数传递时,是把对象的引用传递了;所以在方法内,如果对对象的引用进行操作,就会直接对对象进行改变
(脑补小知识:引用指向的是存储对象的一段内存)

静态域和静态方法

静态域

  • 静态变量
    若将某个变量声明为static,则这个类和其所有对象共享一个值;
    而内存中值存在一份;

  • 静态常量

    1
    public static final double PI = 3.1415;

静态方法

不需要实例化对象就可以调用的方法;可以直接用类名进行调用;

应用场景: 工具类、一个访问只需要访问类的静态域

类成员初始化

  • 类的初始化:值初始化一次,类的初始化主要是初始化静态变量;
    先按照静态成员变量的定义顺序在类内部声明成员变量;
    再按照原Java类中对成员变量的初始化顺序进行初始化

包(package)

更好的组织类

  • 包的作用
    1.将功能相似或相关的类或接口组织在同个包中,便于查找和使用

2.像文件夹一样,采用树形目录的存储方式;同一个包的类名称是不同的,不同包的类名是可以相同的;可有效避免名称的冲突

3.包也限定了访问权限;拥有包访问权限的类才能访问某个包中的类;

注释

1.”//“、”//“

2.javadoc标签

标签 描述 示例
@author 标识一个类的作者 @author description
@deprecated 指明一个过期的类或成员 @deprecated description
{@docRoot} 指明当前文档根目录的路径 Directory Path
@exception 标识一个类抛出的异常 @exception exception-name explanation
{@inheritDoc} 从直接父类继承的注释 Inherits a comment from the immediate surperclass.
{@link} 插入一个到另一个主题的链接 {@link name text}
{@linkplain} 插入一个到另一个主题的链接,但是该链接显示纯文本字体 Inserts an in-line link to another topic.
@param 说明一个方法的参数 @param parameter-name explanation
@return 说明返回值类型 @return explanation
@see 指定一个到另一个主题的链接 @see anchor
@serial 说明一个序列化属性 @serial description
@serialData 说明通过writeObject( ) 和 writeExternal( )方法写的数据 @serialData description
@serialField 说明一个ObjectStreamField组件 @serialField name type description
@since 标记当引入一个特定的变化时 @since release
@throws 和 @exception标签一样. The @throws tag has the same meaning as the @exception tag.
{@value} 显示常量的值,该常量必须是static属性。 Displays the value of a constant, which must be a static field.
@version 指定类的版本 @version info

3.文档注释

在开始的/**后,第一行或几行是关于类、变量和方法的主要描述

javadoc或输出一些包含程序注释的HTML文件


接口

接口:interface,是一种抽象类型,是抽象方法的集合;用interface来声明;
类通过集成接口的方式,来集成接口的抽象方法;

接口不是类,但是编写接口和类相似;

类描述对象的属性和方法,接口则包含类要实现的方法;

类要实现所继承的接口的所有方法;

接口无法被实例化,但可以被实现(用类实现);

在 Java 中,接口类型可用来声明一个变量,他们可以成为一个空指针,或是被绑定在一个以此接口实现的对象

1
2
3
4
5
[可见度] interface 接口名称 [extends 其他的类名] {
// 声明变量
// 抽象方法
}

抽象类

用abstract class声明

抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能实例化对象,所以抽象类必须被继承,才能被使用。

通常在设计阶段决定是否要设计抽象类


抽象类和接口的区别

  1. 抽象类中的方法可以有方法体,就是能实现方法的具体功能,但是接口中的方法不行。
  2. 抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是 public static final 类型的。
  3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法),而抽象类是可以有静态代码块和静态方法。
  4. 一个类只能继承一个抽象类,而一个类却可以实现多个接口。

内部类

顾名思义,就是声明在类内部的类;

  • 成员内部类

最普通的内部类;一个位于类的内部的类;

编译器在进行编译的时候,会将成员内部类单独编译成一个字节码文件;

1
2
3
4
5
6
class Outer{
...
class Inner{
...
}
}

成员内部类可以访问外部类的所有成员属性和成员方法

而外部类想要访问成员内部类的成员,要先创建一个成员内部类的对象,然后通过只想这个对象的引用来访问

成员内部类是依附外部类而存在的,也就是说,如果要创建成员内部类的对象,前提是必须存在一个外部类的对象

内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限

  • 局部内部类
    定义在一个方法或一个作用域内的类;
    仅作用于方法或作用域内;

  • 匿名内部类
    编写事件监听的代码时使用匿名内部类不但方便,而且使代码更加容易维护

1
2
3
4
button.setOnClickListener(new OnClickListener(){
...
});
  • 静态内部类
    类内部的,用static修饰;

静态内部类是不需要依赖于外部类的;

没有一个指向外部类的指针;

继承

子类拥有父类非private的属性,方法。
子类可以拥有自己的属性和方法,即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
Java的继承是单继承,但是可以多重继承,单继承就是一个子类只能继承一个父类,多重继承就是,例如A类继承B类,B类继承C类,所以按照关系就是C类是B类的父类,B类是A类的父类,这是java继承区别于C++继承的一个特性。
提高了类之间的耦合性(继承的缺点,耦合度高就会造成代码之间的联系)。

类设计技巧

  • 将数据设计为私有
    不要破坏封装性
    需要编写一个访问器方法或更改器方法,但是最好还是保持实例域的私有性

  • 一定要对数据初始化
    Java不对局部变量进行初始化,但是会对对象的实例域进行初始化。
    不要依赖于系统的默认值,而是应该显式地初始化所有的数据

  • 不要在类中使用过多的基本数据类型
    用其他的类代替多个相关的基本数据类型的使用。这样会使类更加易于理解且易于修改。

  • 不是所有的域都需要独立的域访问器和域更改器

  • 使用标准格式进行类的定义
    一定采用下面的顺序书写类的内容:
    公有访问特性部分
    包作用域访问特性部分
    私有访问特性部分
    在每一部分中,应该按照下列顺序列出:
    实例方法
    静态方法
    实例域
    静态域

  • 将职责过多的类进行分解

  • 类名和方法名要能够体现它们的职责