Java基本语言特性

常量、变量、枚举、数组

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

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

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中规定的值；

public enum Color{
    RED,GREEN,BLUE ; 
};

public class Main{
	public static void main(String args[]){
		Color c = Color.BLUE;
	}
}

以上是基本用法；

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

1.在switch中使用

2.直接充当常量使用

3.向枚举中添加新方法

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.覆盖枚举的方法

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对象时所有对象的顶级父类

以下记录一些常用方法

```
  equals(Object obj)
```
```
  finalize()
```
```
  getClass
```
```
  hashCode()
```
```
  notify
```
```
  notifyAll();
```
```
  wait()
```
```
  Clone()
```
```
  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语句

if(){
	
}else if(){
	
}else{
	
}

循环语句

1.for(,)语句；

1
2
3

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

2.while语句；

while(boolean){
	
}

do{
	
}while()

switch语句

switch(){
	case xxx :
		...
		break;
	case xxx :
		...
		break;
	default :
		break;
}

面向对象程序

面向对象程序设计概述

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

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

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

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

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

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

类(class)基本概念

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

类利用class定义


public class Dog{
	String bread;
	int age;
	String color;
	
	void barking(){
		...
	}

	void hungry(){
		...
	}

	void sleeping(){
		...
	}
}

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

一个类可以包括：局部变量，成员变量，类变量；

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

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

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

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

**构造方法：**每个类都有构造方法，如果没有显式的定义构造方法，Java编译器会提供一个默认的；

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 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象


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

抽象类

用abstract class声明

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

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

抽象类和接口的区别

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

内部类

顾名思义，就是声明在类内部的类；

成员内部类

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

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

class Outer{
	...
	class Inner{
		...
	}
}

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

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

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

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

局部内部类
定义在一个方法或一个作用域内的类；
仅作用于方法或作用域内；
匿名内部类
编写事件监听的代码时使用匿名内部类不但方便，而且使代码更加容易维护


button.setOnClickListener(new OnClickListener(){
	...
});

静态内部类
类内部的，用static修饰；

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

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

继承

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

类设计技巧

将数据设计为私有
不要破坏封装性
需要编写一个访问器方法或更改器方法，但是最好还是保持实例域的私有性
一定要对数据初始化
Java不对局部变量进行初始化，但是会对对象的实例域进行初始化。
不要依赖于系统的默认值，而是应该显式地初始化所有的数据
不要在类中使用过多的基本数据类型
用其他的类代替多个相关的基本数据类型的使用。这样会使类更加易于理解且易于修改。
不是所有的域都需要独立的域访问器和域更改器
使用标准格式进行类的定义
一定采用下面的顺序书写类的内容：
公有访问特性部分
包作用域访问特性部分
私有访问特性部分
在每一部分中，应该按照下列顺序列出：
实例方法
静态方法
实例域
静态域
将职责过多的类进行分解
类名和方法名要能够体现它们的职责

Java基础复习