(1)变量是内存中装载数据的小盒子, 你只能用它来存数据和取数据.
(2)变量必须要有明确的类型
(3)定义基本类型变量 (创建变量) 数据类型 变量名 = 数据值;
例如: int a = 100;
(4)变量不赋值不能使用. 变量使用时有作用域的限制. 变量不可以重复定义.
(5)变量类型转换:
范围小的数据类型 变量 = (范围小的数据类型) 范围大的数据类型值; 如: int i = (int)6.712 ; //i 的值为 6
范围大的数据类型 变量 = 范围小的数据类型值; 如: int i=100;double d2=i;
2. 引用数据类型
(1)定义引用类型的变量 : 数据类型 变量名 = new 数据类型();
(2)调用该类型实例的功能 : 变量名. 方法名();
例如: Scanner 类(使用该类来完成用户键盘录入, 获取到录入的数据)
Scanner 使用步骤:
导包: import java.util.Scanner;
创建对象实例: Scanner sc = new Scanner(System.in);
调用方法:
- import java.util.Scanner;
- public class demo {
- public static void main(String[] args) {
- Scanner sc = new Scanner(System.in);
- // 输入 int 型的变量 i 和 string 类型的变量 s
- int i = sc.nextInt(); // 用来接收控制台录入的数字
- String s = sc.next(); // 用来接收控制台录入的字符串
- // 输出 i 和 s
- System.out.println(i);
- System.out.print(s);
- }
- }
random 类(产生多种数据类型的随机数)
random 使用步骤:
导包: import java.util.Random;
创建对象实例: Random r = new Random();
方法简介
public int nextInt(int maxValue) 产生 [0,maxValue) 范围的随机整数, 包含 0, 不包含 maxValue;
public double nextDouble() 产生 [0,1) 范围的随机小数, 包含 0.0, 不包含 1.0.
- import java.util.Random;
- public class demo {
- public static void main(String[] args) {
- // 创建 Random 类的实例
- Random r = new Random();
- //public int nextInt(int maxValue)产生 [0,maxValue) 范围的随机整数
- int i = r.nextInt();
- //public double nextDouble()产生 [0,1) 范围的随机小数, 包含 0.0, 不包含 1.0
- double d = r.nextDouble();
- System.out.println(i);
- System.out.print(d);
- }
- }
3. 数组
3.1 一维数组
(1)定义数组: 数据类型[] 数组名 = new 数据类型[元素个数或数组长度];
例如: int[] x = new int[100];
(2)数组的静态初始化有两种方式:
1, 类型[] 数组名 = new 类型[]{元素, 元素,......};
2, 类型[] 数组名 = {元素, 元素, 元素,......};
- public class demo {
- public static void main(String[] args) {
- // 定义数组
- int[] a = new int[10];
- // 对数组进行静态初始化赋值 S
- int[] b = { 4, 5, 6, 7 };
- System.out.println("数组 b 的元素为:");
- for (int i = 0; i <b.length; i++)
- System.out.print(b[i] + " "); // 4 5 6 7
- System.out.println("\n 数组 a 的元素为:");
- for (int i = 0; i < a.length; i++)
- System.out.print(a[i] + " "); // 0 0 0 0 0 0 0 0 0 0
- }
- }
3.2 二维数组
(1)定义数组的方式有以下三种:
第一种: int[][] arr = new int[3][4];
定义了一个 3*4 的二维数组, 即二维数组的长度为 3, 二维数组中的每个元素又是一个长度为 4 的数组
第二种: int[][] arr = new int[3][];
第二种方式和第一种类似, 二维数组的长度为 3, 但是数组中每个元素的长度不确定
第三种方式: int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};
- public class demo {
- public static void main(String[] args) {
- // 定义二维数组
- int[][] a = new int[3][4];
- System.out.println("二维数组 a 的长度为:" + a.length);
- int[][] arr2 = { { 1, 2 }, { 3, 4, 5 }, { 6, 7, 8, 9, 10 } };
- System.out.println("输出二维数组 arr2 的元素:");
- for (int i = 0; i < arr2.length; i++) {
- for (int j = 0; j < arr2[i].length; j++) {
- System.out.print(arr2[i][j] +" ");
- }
- System.out.println();
- }
- }
- }
4. 方法
(1)声明一个方法的具体语法格式如下:
修饰符 返回值类型 方法名(参数类型 参数名 1, 参数类型 参数名 2,......){
执行语句
.........
return 返回值;
- }
- // 下面定义了一个求矩形面积的方法, 接收两个参数, 其中 x 为高, y 为宽
- public static int getArea(int x, int y) {
- int temp = x * y; // 使用变量 temp 记住运算结果
- return temp; // 将变量 temp 的值返回
- }
(2)方法重载
Java 允许在一个类中定义多个名称相同的方法, 但是参数的类型或个数必须不同, 这就是方法的重载
下面的三个方法互为重载关系
public static int add(int x,int y) {逻辑} // 两个整数加法
public static int add(int x,int y,int z) {逻辑} // 三个整数加法
public static int add(double x,double y) {逻辑} // 两个小数加法
- public class demo {
- // 方法的重载
- public static int myadd(int a,int b){
- return a+b;
- }
- public static double myadd(double a,double b){
- return a+b;
- }
- public static String myadd(String a,String b){
- return a+b;
- }
- public static void main(String[] args) {
- int sum1 = myadd(1,2);
- double sum2 = myadd(1.3,2.6);
- String sum3 = myadd("132","0923");
- System.out.println(sum1);
- System.out.println(sum2);
- System.out.println(sum3);
- }
- }
5.ArrayList 集合
ArrayList 集合是程序中最常见的一种集合, 它属于引用数据类型(类). 在 ArrayList 内部封装了一个长度可变的数组, 当存入的元素超过数组长度时, ArrayList 会在内存中分配一个更大的数组来存储这些元素, 因此可以将 ArrayList 集合看作一个长度可变的数组.
5.1. 使用步骤
导包: import java.util.ArrayList;
创建对象: 与其他普通的引用数据类型创建方式完全相同, 但是要指定容器中存储的数据类型:
ArrayList < 要存储元素的数据类型> 变量名 = new ArrayList < 要存储元素的数据类型>();
注明:"<要存储元素的数据类型>" 中的数据类型必须是引用数据类型, 不能是基本数据类型
通过举几个例子, 来明确集合的创建方式:
存储 String 类型的元素
ArrayList<String> list = new ArrayList<String>();
存储 int 类型的数据
ArrayList<Integer> list = new ArrayList<Integer>();
存储 Phone 类型的数据
ArrayList<Phone> list = new ArrayList<Phone>();
5.2 ArrayList 集合中常用方法
- import java.util.ArrayList;
- public class demo {
- public static void main(String[] args) {
- //ArrayList 类的使用
- ArrayList<Integer> alist = new ArrayList<Integer>();
- alist.add(3);// 将元素加入集合的末尾
- alist.add(5);
- for(int i = 0;i<alist.size();i++){//size()得到集合元素个数
- System.out.println(alist.get(i));//get(i)得到指定下标的集合元素
- }
- System.out.println();
- alist.add(1,4);//add(index,obj)将指定元素 obj 插入到集合中指定的位置
- for(int i = 0;i<alist.size();i++){
- System.out.println(alist.get(i));
- }
- System.out.println();
- int c = alist.remove(1);//remove(int index)从集合中删除指定 index 处的元素, 返回该元素
- System.out.println("被删除数 c ="+c);
- for(int i = 0;i<alist.size();i++){
- System.out.println(alist.get(i));
- }
- System.out.println();
- alist.set(1,9);//set(int index, Object obj)用指定元素 obj 替代集合中指定位置上的元素
- for(int i = 0;i<alist.size();i++){
- System.out.println(alist.get(i));
- }
- System.out.println();
- alist.clear();//clear()清空集合中所有元素
- for(int i = 0;i<alist.size();i++){
- System.out.println(alist.get(i));
- }
- System.out.println();
- }
- }
6. 继承
以下在 Demo.java 文件内编写:
- /*
- * 定义员工类 Employee
- */
- class Employee {
- String name; // 定义 name 属性
- // 定义员工的工作方法
- public void work() {
- System.out.println("尽心尽力地工作");
- }
- }
- /*
- * 定义研发部员工类 Developer 继承 员工类 Employee
- */
- class Developer extends Employee {
- // 定义一个打印 name 的方法
- public void printName() {
- System.out.println("name=" + name);
- }
- }
- /*
- * 定义测试类
- */
- public class demo {
- public static void main(String[] args) {
- Developer d = new Developer(); // 创建一个研发部员工类对象
- d.name = "小明"; // 为该员工类的 name 属性进行赋值
- d.printName(); // 调用该员工的 printName()方法
- d.work(); // 调用 Developer 类继承来的 work()方法
- }
- }
7. 接口和抽象的区别
(1)例子
解释:
由于犬分为很多种类, 他们吼叫和吃饭的方式不一样, 在描述的时候不能具体化, 也就是吼叫和吃饭的行为不能明确.
当描述行为时, 行为的具体动作不能明确, 这时, 可以将这个行为写为抽象行为, 那么这个类也就是抽象类.
可是当缉毒犬有其他额外功能时, 而这个功能并不在这个事物的体系中.
这时可以让缉毒犬具备犬科自身特点的同时也有其他额外功能, 可以将这个额外功能定义接口中.
抽象类存的是公共都有的功能(但其具体实现不同), 而接口可存额外功能.
- interface jidu{// 缉毒
- public abstract void jidu();
- }
- // 定义犬科的共性功能
- abstract class dog{
- public abstract void eat();
- public abstract void speak();
- }
- // 缉毒犬属于犬科一种, 让其继承犬科, 获取的犬科的特性,
- // 由于缉毒犬具有缉毒功能, 那么它只要实现缉毒接口即可, 这样即保证缉毒犬具备犬科的特性, 也拥有了缉毒的功能
- class jidu_dog extends dog implements jidu{
- public void jidu() {
- }
- public void eat() {
- }
- public void speak() {
- }
- }
(2)通过上面的例子总结接口和抽象类的区别
相同点:
都位于继承的顶端, 用于被其他类实现或继承;
都不能直接实例化对象;
都包含抽象方法, 其子类都必须覆写这些抽象方法;
区别:
抽象类为部分方法提供实现, 避免子类重复实现这些方法, 提高代码重用性; 接口只能包含抽象方法;
一个类只能继承一个直接父类(可能是抽象类), 却可以实现多个接口;(接口弥补了 Java 的单继承)
抽象类是这个事物中应该具备的你内容, 继承体系是一种 is..a 关系
接口是这个事物中的额外内容, 继承体系是一种 like..a 关系
二者的选用:
优先选用接口, 尽量少用抽象类;
需要定义子类的行为, 又要为子类提供共性功能时才选用抽象类;
来源: http://www.bubuko.com/infodetail-3354648.html