Java学习入门

Java学习入门

字符串

java虚拟机在启动的时候会实例化9个对象池，用来存放8种基本类型的包装类对象和String类对象

赋值前，先判断被赋予的值在对象池中是否存在，如果存在则指向该对象；__不存在__则创建这个对象。

对象变量的赋值，实际为让b来管理a的对象池

创建字符串的方式

1.在对象池中创建

String str1 = "helloworld";

2.内存中new一个String对象

String str2 = new String("helloworld");

3.通过字符数组创建字符串

char[] chs = {'h','e','l','l','o'};
String str3 = new String(chs);

4.通过byte数组创建字符串

byte[] byt = {104,101,108,108,111};
String str4 = new String(byt);

构造方法

每一个类的传入参数的设置

getter和setter函数

访问和设置设置该类的公用变量(?)的值

static

公共属性

加static后的方法不用new就可以调用

覆盖@Override

常见覆盖toString

@Override
public String toString() {
	return "this:"+ this +"is the new geshi!";
}

数组

数组声明及定义

//常用
int a[];
int a[] = {1,2,3,4};
//用new在内存中开辟一个空间
//声明时必须给定初始长度
int[] b = new int[5];
int[] b = new int[]{1,2,3,4};

数组遍历

//普通遍历
for(int i = 0;i < e.length;i ++)
{
	System.out.println(e[i]);
}
//增强遍历？！
for(String str : strs) {
	System.out.println(str);
}

数组排序

自带的排序函数

Arrays.sort(i);//其中i为数组名

随机数生成

import java.util.Random
//随机数生成类
Random random = new Random();
//生成随机数:[0,100)
int cnt = random.nextInt(100);

Scanner输入流

import java.util.Scanner
//创建Scanner对象：通过系统默认输入流创建
Scanner input = new Scanner(System.in);
//得到需要的对象
String str = input.nextLine();

二维数组

int [][]a = new int[][];

字符类型

单个的字符

输出、计算、大小写转换

逃逸字符

无法印出来的控制字符或特殊字符，由反斜杠开头，后跟另一个字符

包裹类型

每种基础类型都有对应的包裹类型

boolean Boolean
char    Charater
int 	Integer
double	Double

当需要让一个类或对象做事情的时候，由点运算

boolean isDigit(char a);   //判断字符a是不是数字
isLetter(char a); 	 //判断字符a是不是字母
isLowerCase(char a);
isUpperCase(char a);
isWhitespace(char a);
char toLowerCase(char a);  //转换成小写字符

Math类型

abs、pow、random、round（四舍五入）

函数

函数的定义

一块代码，接受零个或多个参数，做一件事情，并返回零个或一个值

函数的调用

（）起到了表示函数调用的重要作用，没有参数也需要

函数的参数

一一对应！永远只能传值。限于Java

本地变量

函数每次的运行，就产生一个独立的变量空间，在这个空间的变量，是函数的这次运行所独有的，称作本地变量

作用域只在这个块中，不会被默认初始化。

对象

对象的识别

用类制造对象

对象是实体，需要被创建，可以为我们做事情

类是规范，根据类的定义来创造对象

举例：

对象（这只猫）：表达东西或事件、运行时响应消息

类（猫）：定义所有猫的属性、Java中的类型、可以用来定义变量

把数据和对数据的操作放在一起->封装

定义类

• 对象变量是对象的管理者

成员变量

函数是通过对象来调用的->点运算

this是特有的固定的本地变量

对象初始化

构造函数进行对象中的变量初始化

没有返回类型

函数重载：

• 一个类可以有多个构造函数，只要他们的参数表不同；

• 通过this()可以调用其它的构造函数；

• 一个类里的同名但参数表不同的函数构成了重载关系；

对象的交互

一个管理对象对所需目标对象进行管理。

只有new了之后才是创建了对象。

访问属性

封闭的访问属性

private（私有的）：只有这个类内部可以访问、这个限制是对类的不是对对象的

开放的访问属性

public（都可以进行访问）、friendly（在一个包里可以进行访问）、protected

编译单元：一个.Java文件只能有一个public class可以有多个class（此class只能在当前编译单元进行访问）

包

import 导入另一个包里的类（包名.所需类）

or

不导入的话可以输入类的全名

一个点表示一个文件层次。

类

类变量

static

可以用类的名字加.进行访问

加了这个属性的变量只属于这个类，不属于任何对象

类方法

加了static的函数，和对象没有关系，属于这个类

在static函数里只能调用static的函数和变量（可以通过对象调用，但不是对象的具体情况）

记事本的例子

需求确定

接口设计

tips：分工要业务逻辑与ui分开

泛型容器类

ArrayList<String> notes = new ArrayList<string>();

容器的类型：ArrayList

元素的类型：String

//操作
notes.add(s); // String s;

对象数组

int 
int[] a = new int[10];
//int型的元素

String s;
String[] s = new String[];
//对象数组的每个元素都是对象的管理者而非对象本身

对象数组的FOR-EACH循环

//数据类型
对其操作，不会有变化
//对象数组
for (Value v : a ) {
	对其所管理的
}
//泛型容器也ok

集合容器

HashSet<String> s = new HashSet<String>();
//集合的特征：
//元素不会重复

Hash表

HashMap<Integer, String> coinnames = new HashMap<Integer, String>();

//操作
coinnames.put(key, value);
if ( coinnames.containsKey(amount) )
	return coinnames.get(amount);
else
	return "NOT FOUND!";
//同一个键放多个值，只保存最后一次的值
//遍历
for (Integer k : coinnames.keySet() ) {
	String s = coinnames.get(k);
	System.out.println(s);
}

媒体资料库的设计

继承

子类继承了父类什么

父类中的private可以改为protected，让子类也可以访问；

or

为private的变量进行新建一个构造器，用super(title);进行处理；

一定是父类的定义初始化和构造器执行完成，再进行子类的定义初始化和构造器的执行

子类和父类的关系

子类中的变量与父类中的变量重名时，子类中this访问的是子类的值，进入父类后又是父类中的值

多态变量

子类和子类型

类定义了类型

子类定义了子类型

子类的对象可以被当作父类的对象来使用

• 赋值给父类
• 传递给需要父类对象的容器
• 放进存放父类对象的容器

子类型与赋值

Vehicle v1 = new Vehicle();
Vehicle v2 = new Car();

子类的对象可以赋值给父类的变量

子类和参数传递

CD cd = new CD();
database.add(cd);

子类的对象可以传递给需要父类对象的函数

子类型和容器

关系图

多态变量

• Java的对象变量是多态的，它们能够保存不止一种类型的对象
• 它们可以保存的是声明类型的对象，或声明类型的子类的对象
• 当把子类的对象付给父类的变量的时候，就发生了向上造型

向上造型

造型cast

• 子类的对象可以赋值给父类的变量，父类的对象不能赋值给子类变量

  Vehicle v;
  Car c = new Car();
  v = c;             //可以
  c = v;             //编译错误
  

• 可以用造型

  c = (Car) v;
  (只有当v这个变量实际管理的是Car才行)
  

Tips：类型转换vs造型

造型：看成什么来对待

类型转换：转换成

多态

函数调用的绑定

当通过对象变量调用函数的时候，调用哪个函数这件事情叫做绑定

• 静态绑定：根据变量的声明类型来决定（编译的时候就知道）
• 动态绑定：根据变量的动态类型来决定（只有执行程序的时候才知道调用的是哪个函数）

在成员函数中调用其它成员函数也是通过this这个对象变量来调用的（动态绑定）

覆盖

• 子类和父类的变量中存在名称和参数表完全相同的函数，这一对函数构成覆盖关系

• 通过父类的变量调用存在覆盖关系的函数时，会调用变量当时所管理的对象所属的类的函数

Object类

函数

• toString()
• equal()

城堡游戏设计

消除代码复制

封装

用封装来降低耦合

• Room类和Game类都有大量的代码和出口相关

• 尤其是Game类中大量使用了Room类的成员变量

• 类和类之间的关系称作耦合

• 耦合越低越好，保持距离是形成良好代码的关键

类成员变量应当尽量私有

可扩展性

用接口来实现聚合

1. 给Room类实现的新方法，把方向的细节彻底隐藏在Room类内部了
2. 今后方向如何实现就和外部无关了
3. List item