* 对象
* 类
* 成员方法
* 构造方法
* 常量
* 变量：局部变量、类变量(静态变量)、成员变量
* Java大小写敏感，类名首字母大写，方法名首字母小写，源文件名与类名相同，主方法口：public static void main(String []args)
* Java标识符：以字母 $ _ 开头,首字符之后可以是字母 $ _ 数字
* 访问控制符：public protected default private
* 修饰符：static final abstract synchronized transient volatile
* 八种基本数据类型：byte short int long float double boolean char
* 类型转换
* 算术运算符： + - * / % ++ --
* 关系运算符: == != > < >= <=
* 逻辑运算符：&& || ！
* 位运算符
* 赋值运算符：= += -= *= /= %= 等
* 三元运算符：c = a>b ? d : e
* 循环结构：while循环 do...while循环 for循环
* 分支结构：if语句 switch语句
* Number类 Math类 Character类 String类 StringBuffer类 Scanner类
* Java异常处理
* Java继承
* Java Override/Overload
* Java多态
* Java抽象类
* Java封装
* Java接口
* Java package
* Java 网络编程
* Java多线程
* Java数据结构
* 迭代器
1.类和对象
package test;
/*
* Java对象和类：
* 对象：对象是类的一个实例，有状态和行为。
* 类：类是一个模板，描述一类对象的行为和状态。
* Java中的类
* 类包含以下类型变量：
* 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
* 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
* 类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。
* 构造方法：每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。
* 创建对象：
* 声明：声明一个对象，包括对象名称和对象类型。
* 实例化：使用关键字new来创建一个对象。
* 初始化：使用new创建对象时，会调用构造方法初始化对象。
* */
public class Test {
//两个成员变量
int age;
String sex;
//两个构造方法：一个不带参数，一个带参数
public Test(){
System.out.println("构造方法一！");
}
public Test(String name){
System.out.println("构造方法二：" + name);
}
//定义一个方法
public void huhu(){
int h = 11;//定义一个局部变量
System.out.println("调用方法，局部变量值："+h);
}
public static void main(String []args){
//下面两个对象在创建的时候使用了不同的构造方法
Test myTest = new Test();//创建一个myTest对象
myTest.age = 11;//给对象的属性设定值
myTest.sex = "男";
myTest.huhu();//调用方法
System.out.println("myTest的age和sex分别是："+myTest.age+','+myTest.sex);//访问成员变量
Test myTest2 = new Test("狗狗");
myTest2.age = 13;
myTest2.sex = "女";
myTest2.huhu();//调用方法
System.out.println("myTest2的age和sex分别是："+myTest2.age+','+myTest2.sex);//访问成员变量
}
}
Snip20170918_1.png
2.java基本数据类型
/*
*Java基本数据类型
* byte：有符号整数，一个字节，(-2^7 ~ 2^7-1)
* short:有符号整数，两个字节，(-2^15 ~ 2^15-1)
* int:有符号整数，四个字节，(-2^31 ~ 2^31-1)
* long:有符号整数，八个字节，(-2^63 ~ 2^63-1)
* float:单精度浮点数，四个字节
* double:双精度浮点数，八个字节
* boolean:true/false
* char:两个字节
*Java 中使用 final 关键字来修饰常量
* */
public class Test {
public static void main(String []args){
System.out.println("基本类型：byte,short,int,long,float,double,char的位数："+Byte.SIZE+','+Short.SIZE+','+Integer.SIZE+','+Long.SIZE+','+Float.SIZE+','+Double.SIZE+','+Character.SIZE);
final double PI = 3.1415927;
System.out.println("常量PI的值："+PI);
}
}
Snip20170918_3.png
3.Java变量类型
/*
*Java变量
* 声明变量的基本格式：type identifier = value;
* 变量类型：
* 类变量：独立于方法之外的变量，用 static 修饰。
* 类变量也称为静态变量，在类中以static关键字声明，但必须在方法构造方法和语句块之外。
* 无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
* 静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。
* 静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
* 静态变量在程序开始时创建，在程序结束时销毁。
* 与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
* 默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
* 静态变量可以通过：ClassName.VariableName的方式访问。
* 类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。
* 实例变量：独立于方法之外的变量，不过没有 static 修饰。
* 实例变量声明在一个类中，但在方法、构造方法和语句块之外；
* 当一个对象被实例化之后，每个实例变量的值就跟着确定；
* 实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
* 实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
* 实例变量可以声明在使用前或者使用后；
* 访问修饰符可以修饰实例变量；
* 实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
* 实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
* 实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。
* 局部变量：类的方法中的变量。
* 局部变量声明在方法、构造方法或者语句块中；
* 局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
* 访问修饰符不能用于局部变量；
* 局部变量只在声明它的方法、构造方法或者语句块中可见；
* 局部变量是在栈上分配的。
* 局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
*
* */
public class Test {
static int age ;//类变量
String sex;//实例变量
public void pup(){
int a = 0;//局部变量
a = a + 7;
System.out.println("局部变量a的值："+a);
}
public static void main(String []args){
Test test = new Test();
age = 10;
test.sex = "男";
System.out.println("类变量age的值："+age+"成员变量sex的值："+test.sex);
test.pup();
}
}
Snip20170918_4.png
4.Java修饰符
/*
*Java修饰符
* 访问控制修饰符
* default (即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
* private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
* public : 对所有类可见。使用对象：类、接口、变量、方法
* protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
* 非访问修饰符
* static 修饰符，用来修饰类方法和类变量。
* 静态变量：static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。
* 静态方法：static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。
* final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
* abstract 修饰符，用来创建抽象类和抽象方法。
* synchronized 和 volatile 修饰符，主要用于线程的编程。
*
* */
5.Java运算符
/*
*Java运算符
* 算术运算符
* + - * / % ++ --
* 关系运算符
* == != > < >= <=
* 位运算符
* & | ^ ~ << >> >>>
* 逻辑运算符
* &&(逻辑与) ||(逻辑或) !(逻辑非)
* 赋值运算符
* = += -= *= /=
* 其他运算符
* 三元运算符：variable x = (expression) ? value if true : value if false
* instanceof运算符：检查该对象是否是一个特定类型
*
* */
6.Java循环
/*
*Java循环结构
* while
* do...while
* for
* break关键字 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。
* continue关键字 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
* */
public class Test {
public static void main(String []args){
//while循环
int x = 0;
while(x < 10){
if(x == 5){
break;//结束循环
}
System.out.println("value of x :"+x);
x++;
}
//do...while循环
System.out.println();
int y = 1;
do{
System.out.println("value of y :"+y);
y++;
}while(y<5);
//for循环
System.out.println();
for(int i = 0; i<5; i++){
if(i == 3){
continue;//结束本次循环，继续循环
}
System.out.println("value of i :"+i);
}
//增强for循环
String [] names = {"a", "b", "c", "d", "e"};
for(String name: names){
System.out.println(name);
}
}
}
Snip20170918_5.png
7.Java分支结构
/*
*Java分支结构
* if语句
* switch语句
* */
public class Test {
public static void main(String []args){
int x = 30;
if(x == 10){
System.out.println("value of x is 10");
}else if(x == 20){
System.out.println("value of x is 20");
}else if(x == 30){
System.out.println("value of x is 30");
}else{
System.out.println("这是 else 语句");
}
char grade = 'C';
switch(grade){
case 'A':
System.out.println("优秀");
break;
case 'B':
System.out.println("良好");
break;
case 'C':
System.out.println("及格");
break;
case 'D':
System.out.println("不及格");
break;
default:
System.out.println("未知等级");
}
}
}
Snip20170918_6.png
8.Java Number & Math 类
/*
*Java Number & Math 类
* Number & Math 类方法
* xxxValue():将 Number 对象转换为xxx数据类型的值并返回 byteValue() doubleValue() floatValue() intValue() longValue() shortValue()
* compareTo():将number对象与参数比较。两个不同类型的数据不能用此方法来比较
* equals():判断number对象是否与参数相等。
* valueOf():返回一个 Number 对象指定的内置数据类型
* toString():以字符串形式返回值。
* parseInt():将字符串解析为int类型。
* abs():返回参数的绝对值。
* ceil():对整形变量向左取整，返回类型为double型。对一个数进行上舍入,返回值大于或等于给定的参数
* floor():对整型变量向右取整。返回类型为double类型,小于或等给定的参数
* rint():返回与参数最接近的整数。返回类型为double。
* round():返回一个最接近的int、long型值。
* min():返回两个参数中的最小值。
* max():返回两个参数中的最大值。
* exp():返回自然数底数e的参数次方。
* log():返回参数的自然数底数的对数值。
* pow():返回第一个参数的第二个参数次方。
* sqrt():求参数的算术平方根。
* sin():求指定double类型参数的正弦值。
* cos():求指定double类型参数的余弦值。
* tan():求指定double类型参数的正切值。
* asin():求指定double类型参数的反正弦值。
* acos():求指定double类型参数的反余弦值。
* atan():求指定double类型参数的反正切值。
* atan2():将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。
* toDegrees():将参数转化为角度。
* toRadians():将角度转换为弧度。
* random():返回一个随机数。
* */
public class Test {
public static void main(String []args){
Integer x = 5;
System.out.println(x.doubleValue());//返回double原生数据类型
System.out.println(x.compareTo(3));//相等返回0，小于返回-1，大于返回1.
Integer y = 5;
System.out.println(x.equals(y));//与方法的参数类型与数值都相等返回 True，否则返回 False。
System.out.println(Float.valueOf("80"));//参数为 Integer 对象的整数或者字符串
System.out.println(x.toString());
System.out.println(Double.parseDouble("5"));
System.out.println(Math.abs(-6));//返回参数的绝对值
System.out.println(Math.ceil(3.43));
System.out.println(Math.ceil(-3.43));//参数为double 或 float
System.out.println(Math.floor(4.6));
System.out.println(Math.floor(-4.6));//返回 double 类型数组，小于或等于给定的参数
System.out.println(Math.rint(100.6));
System.out.println(Math.rint(100.5));//返回 double 类型数组，是最接近参数的整数值
System.out.println(Math.round(100.6));
System.out.println(Math.round(100.5));//参数为double,float,返回一个最接近的int、long型值
System.out.println(Math.min(12.3, 12.4));
System.out.println(Math.max(12.3, 12.4));
System.out.println(Math.exp(2));//返回自然数底数e的2次方
System.out.println(Math.log(7.38905609893065));//返回参数的自然数底数的对数值。
System.out.println(Math.pow(3, 3));//返回第一个参数的第二个参数次方。
System.out.println(Math.sqrt(4));//返回参数的算术平方根。
System.out.println(Math.random());//用于返回一个随机数，随机数范围为 0.0 =< Math.random < 1.0。
}
}
Snip20170919_7.png
9.Java Character类
/*
*Java Character类
* Character 类用于对单个字符进行操作，Character 类在对象中包装一个基本类型 char 的值
* Character方法
* isLetter():是否是一个字母
* isDigit():是否是一个数字字符
* isWhitespace():是否是一个空格
* isUpperCase():是否是大写字母
* isLowerCase():是否是小写字母
* toUpperCase():指定字母的大写形式
* toLowerCase():指定字母的小写形式
* toString():返回字符的字符串形式，字符串的长度仅为1
* */
public class Test {
public static void main(String []args){
System.out.println(Character.isLetter('c'));
System.out.println(Character.isLetter('5'));
System.out.println();
System.out.println(Character.isDigit('c'));
System.out.println(Character.isDigit('5'));
System.out.println();
System.out.println(Character.isWhitespace('c'));
System.out.println(Character.isWhitespace(' '));
System.out.println(Character.isWhitespace('\n'));
System.out.println(Character.isWhitespace('\t'));
System.out.println();
System.out.println( Character.isUpperCase('c'));
System.out.println( Character.isUpperCase('C'));
System.out.println();
System.out.println( Character.isLowerCase('c'));
System.out.println( Character.isLowerCase('C'));
System.out.println();
System.out.println(Character.toUpperCase('a'));
System.out.println();
System.out.println(Character.toLowerCase('A'));
System.out.println();
System.out.println(Character.toString('a'));
}
}
Snip20170919_8.png
10.Java数组
/*
*Java数组 用来存储固定大小的同类型元素。
* */
public class Test {
public static void main(String []args){
int[] myList = new int[5];//创建数组
myList[0] = 0;
myList[1] = 1;
myList[2] = 2;
myList[3] = 3;
myList[4] = 4;
int total = 0;
for(int i = 0; i < myList.length; i++){
total += myList[i];
}
System.out.println("总和为:"+total);
double[] myList2 = {1.1, 2.2, 3.3, 4.4, 5.5};//创建数组
for(double element: myList2){//遍历数组
System.out.println(element);
}
String s[][] = new String[2][];//二维数组
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String("Good");
s[0][1] = new String("Luck");
s[1][0] = new String("to");
s[1][1] = new String("you");
s[1][2] = new String("!");
for(String[] element: s){
for(String ele: element){
System.out.println(ele);
}
}
}
}
Snip20170919_9.png
11.Java String类
/*
*Java String 类
* String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了
*Java StringBuffer 和 StringBuilder 类
* 和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
* */
public class Test {
public static void main(String []args){
String site = "www.baidu.com";
int len = site.length();//字符串长度
System.out.println("网址长度：" + len);
System.out.println(site.indexOf('b'));//字符b在site中的位置
System.out.println(site.substring(4, 9));//子字符串
System.out.println(site.toUpperCase());//大写
float x = 1.1f;
int y = 2;
String z = "haha";
String fs = String.format("x,y,z三个变量的值为: %f, %d, %s", x, y, z);//创建格式化字符串
System.out.println(fs);
StringBuffer sb = new StringBuffer("官网：");
sb.append("www");
sb.append(".baidu.com");
System.out.println(sb);
}
}
Snip20170919_10.png
12.Java方法
/*
*Java 方法
* Java方法是语句的集合，它们在一起执行一个功能。
* 方法是解决一类问题的步骤的有序组合
* 方法包含于类或对象中
* 方法在程序中被创建，在其他地方被引用
* 一个方法的所有部分：修饰符 返回值类型 方法名(参数类型 参数名){方法体 return 返回值；}
* 修饰符：可选，定义了该方法的访问类型。
* 返回值类型：returnValueType或者void
* 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
* 参数类型：参数是可选的。
* 方法体：方法体包含具体的语句，定义该方法的功能。
* 方法的重载：方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。
* 变量作用域：变量的范围是程序中该变量可以被引用的部分。
* 构造方法：当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。
* finalize()方法：它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做 finalize( )，它用来清除回收对象。
* */
public class Test {
int age;
//构造方法
Test(int i){
age = i;
}
public static void main(String []args){
int i = 5;
int j = 2;
int k = max(i, j);
System.out.println(i + " 和 " + j + " 比较，最大值是：" + k);
double x = 5.5;
double y = 6.6;
double z = max(x,y);
System.out.println(x + " 和 " + y + " 比较，最大值是：" + z);
Test myTest = new Test(10);
System.out.println(myTest.age);
myTest = null;
System.gc();//调用Java垃圾收集器
}
public static int max(int num1, int num2){
int result;
if(num1 > num2){
result = num1;
}else{
result = num2;
}
return result;
}
//方法的重载：方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。
public static double max(double num1, double num2){
double result;
if(num1 > num2){
result = num1;
}else{
result = num2;
}
return result;
}
//指定在对象销毁时候要执行的操作。
protected void finalize(){
System.out.println("对象销毁");
}
}
Snip20170919_11.png
13.Java异常处理
/*
*Java异常处理
* */
public class Test {
public static void main(String []args){
int a[] = new int[2];
try{
System.out.println("Access element three :" + a[3]);
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("Exception thrown :" + e);
}
finally{
a[0] = 6;
System.out.println("First element value: " +a[0]);
System.out.println("The finally statement is executed");
}
}
}
Snip20170919_12.png
14.Java继承
/*
*Java继承
* 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
* 继承的特性：
* 子类拥有父类非private的属性，方法。
* 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
* 子类可以用自己的方式实现父类的方法。
* Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如A类继承B类，B类继承C类，所以按照关系就是C类是B类的父类，B类是A类的父类，这是java继承区别于C++继承的一个特性。
* 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系）。
* 继承关键字：
* extends关键字：在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。
* implements关键字：使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。
* super与this关键字：
* super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
* this关键字：指向自己的引用
* final关键字：final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写。
* */
//父类
class Animal{
protected int age;
void go(){
System.out.println("animal go:");
}
}
//子类继承父类
class Dog extends Animal{
void go(){
//调用父类方法
super.go();
}
}
public class Test {
public static void main(String []args){
Dog dog = new Dog();
dog.age = 10;
System.out.println("age:"+dog.age);
dog.go();
}
}
Snip20170920_1.png
15.Java 重写(Override)与重载(Overload)
/*
*Java 重写(Override)与重载(Overload)
* 重写：重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
* 重写规则：
* 参数列表必须完全与被重写方法的相同；
* 返回类型必须完全与被重写方法的返回类型相同；
* 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
* 父类的成员方法只能被它的子类重写。
* 声明为final的方法不能被重写。
* 声明为static的方法不能被重写，但是能够被再次声明。
* 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
* 子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
* 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
* 构造方法不能被重写。
* 如果不能继承一个方法，则不能重写这个方法。
* 重载：重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
* 重载规则：
* 被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；
* 被重载的方法可以改变返回类型；
* 被重载的方法可以改变访问修饰符；
* 被重载的方法可以声明新的或更广的检查异常；
* 方法能够在同一个类中或者在一个子类中被重载。
* 无法以返回值类型作为重载函数的区分标准。
* */
16.Java多态
/*
*Java 多态
* 多态是同一个行为具有多个不同表现形式或形态的能力
* 多态的优点：
* 1. 消除类型之间的耦合关系
* 2. 可替换性
* 3. 可扩充性
* 4. 接口性
* 5. 灵活性
* 6. 简化性
* 多态存在的三个必要条件
* 继承
* 重写
* 父类引用指向子类对象
* */
class Animal{
public void eat(){
System.out.println("haha");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("吃鱼");
}
}
public class Test {
public static void main(String []args){
Animal a = new Cat();
a.eat();
}
}
Snip20170920_2.png
17.
网友评论