（1）变量是内存中装载数据的小盒子，你只能用它来存数据和取数据。
（2）变量必须要有明确的类型
（3）定义基本类型变量（创建变量）数据类型 变量名 = 数据值；
例如：int a = 100;
(4)变量不赋值不能使用。变量使用时有作用域的限制。变量不可以重复定义。
（5）变量类型转换：
范围小的数据类型 变量 = (范围小的数据类型) 范围大的数据类型值； 如：int i = (int)6.712 ; //i的值为6
范围大的数据类型 变量 = 范围小的数据类型值；如：int i=100;double d2=i;
（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); } }
（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 } }
（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(); } } }
（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); } }
ArrayList集合是程序中最常见的一种集合，它属于引用数据类型（类）。在ArrayList内部封装了一个长度可变的数组，当存入的元素超过数组长度时，ArrayList会在内存中分配一个更大的数组来存储这些元素，因此可以将ArrayList集合看作一个长度可变的数组。
导包：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>();
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(); } }
以下在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()方法 } }
解释：
由于犬分为很多种类，他们吼叫和吃饭的方式不一样，在描述的时候不能具体化，也就是吼叫和吃饭的行为不能明确。
当描述行为时，行为的具体动作不能明确，这时，可以将这个行为写为抽象行为，那么这个类也就是抽象类。
可是当缉毒犬有其他额外功能时，而这个功能并不在这个事物的体系中。
这时可以让缉毒犬具备犬科自身特点的同时也有其他额外功能，可以将这个额外功能定义接口中。
抽象类存的是公共都有的功能（但其具体实现不同），而接口可存额外功能。
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() { } }
相同点:
都位于继承的顶端,用于被其他类实现或继承;
都不能直接实例化对象;
都包含抽象方法,其子类都必须覆写这些抽象方法;
区别:
抽象类为部分方法提供实现,避免子类重复实现这些方法,提高代码重用性;接口只能包含抽象方法;
一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口;(接口弥补了Java的单继承)
抽象类是这个事物中应该具备的你内容, 继承体系是一种 is..a关系
接口是这个事物中的额外内容,继承体系是一种 like..a关系
二者的选用:
优先选用接口,尽量少用抽象类;
需要定义子类的行为,又要为子类提供共性功能时才选用抽象类;
原文：https://www.cnblogs.com/Aiahtwo/p/12112389.html