java 基础 （一 ），java基础
三天突破java （一）
一、 java 概述
1）为什么要学习java ？
java 是一门很火的语言，是目前全球最受欢迎的语言之一，在整个IT行业中，java语言占有很大的市场份额，不了解java不学习java对我们编程人员来说是一个巨大的损失。
目前，嵌入式设备中,如平板，手机所采用的操作系统大部分都是android的，而google 对android 语言和其它几种语言的对比, 和C比提供了很多的类库，方便程序员的开发，降低工程的开发周期，课C++ 相比摒弃了很多C++ 的非常复杂的语法操作，如：指针操作，多继承
2）Java嵌入式的关系
正因为android 如此大的市场，所以现在很多嵌入设备都使用android系统来做图形界面，而学习android首先就要学习java
3）java 的运行机制
java 源码 –(编译)à .class 文件 –(解释、执行)à 虚拟机运行
4）虚拟机的意义
Java中引入了虚拟机的概念，即在机器和编译程序之间加入了一层抽象的虚拟的机器。这台虚拟的机器在任何平台上都提供给编译程序一个的共同的接口。编译程序只需要面向虚拟机，生成虚拟机能够理解的代码，然后由解释器来将虚拟机代码转换为特定系统的机器码执行。在Java中，这种供虚拟机理解的代码叫做字节码（ByteCode），它不面向任何特定的处理器，只面向虚拟机；
5）虚拟机原理
Java虚拟机（Java Virtual Machine,简称JVM）是一种假想的计算机。从结构上看，它由抽象的指令集、寄存器组、类文件格式规定、堆栈、内存垃圾收集器和存储区六个部件组成。指令集采用与平合无关的字节码形式，寄存器组中包含程序计数器、堆栈指针、运行环境指针和变量指针，类文件也与平台无关，堆栈用来传递参数和返回运行结果，垃圾收集器收集不再使用的内存片段，存储区则用来存放字节码。JVM仅仅规定部件的功能和规格。虽然这些功能和规格是统一的，但是并没有规定这此部件的具体实现技术，就是说，可以用任何一种技术来实现。
6）java的垃圾回收机制
java 虚拟机会每隔一段时间去检查内存中没有被释放的内存，采用引用计数机制，如果发现计数为0，则释放它，相比于C++,C 中的用户自己回收内存，java的操作更不容易造成内存泄露
二、java 的开发环境配置
1）安装 java JDK
2）配置path 和 classpath 环境变量（注意windows 不区分大小写）
3）编写简单的HelloWorld.java 程序运行
javac HelloWorld.java // 编译
java HelloWorld // 运行，注意java 后面加的是类名而不是文件名
三 、java 基础学习
1. 程序设计简史
1）程序设计的几种样式
（1）过程化程序设计（LISP ) ： 表链式语言， 如，shell
（2）结构化程序设计 如，C，FORTRAN，PASICAL
（3）面向对象程序设计
如：C++ ， C# ， java
2）程序语言发展的历史
机器 ---> 汇编 ----> 高级 ------> 面向对象
1.类和对象
1）对象：万事万物皆对象
2）类：同一类对象的属性和行为的抽象总结
（1）类描述同一类对象应包括的数据
（2）描述同一类对象的行为特征
（3）类是一个概念模型
注意：类是对象的模板，对象是类的实例
案例：你现在脑海中有一个一辆小轿车，但是你现在没钱买，等你工作两年后，你去4S店买了一辆奇瑞，那么这个事中“脑海中汽车”就是类，而“你买的汽车”就是对象，也就是说现在是一个类创造一个对象，如果一年之后，你又买了一辆奔驰，那么就是一个类创造两个对象、
属性：用来描述对象的数据元素成为对象的属性（也称为数据状态）
方法：对象的属性进行操作成为对象的方法 （也称为行为操作）
3） 类的声明：
如：以一个手机为实体，说明类的定义，
手机的基本特征：
品牌
型号
制式
重量
语法格式：
|
1
2
3
4
5
|
[<modifiers>] class <class_name>{
[<attribute_declaration>] // 属性声明
[<constructor_declaration>] // 构造器声明
[<method_declaration>] // 方法声明
}
|
4)属性的声明//相当于C中成员
|
1
|
1[<modifiers>]type <attr_name>[=defaultValue];
|
5)方法的格式：
|
1
2
3
4
5
6
7
8
|
<modifiers><return_type><name>([<argu_list>]){
[statements]
publicclass Mobie{ //声明一个手机类
private String band; //属性声明
public void setBrand(String _brand){ //方法声明
this.brand = _brand;
}
}
|
案例1：调用一个手机类，设置手机的重量为200g ,并从终端打印出手机所有信息
6）构造器（constructor）的声明
语法:
|
1
2
3
|
<modifier><class_name>([<arugments_list>]){
[<statements>]；
}
|
注意：
（1）构造器的名称必须和类名一致
（2）一个类可以有多个构造器但是构造器的参数列表必须不同
|
1
2
3
4
5
|
public class Mobie{
private int weight;
public Mobie(int w)
weight = w ;
}
|
7) 对象的创建和使用
语法：
构造器：
（1）无参构造器
（2）有参构造器
（3）如果类没有定义构造器，系统会提供默认的无参构造器
8）对象方法和属性的访问
案例2： 创建两个参数构造器，获取手机属性
9） 信息隐藏
信息隐藏：对象的一种保护机制，使得它的属性或方法不被外部程序直接访问
10） 信息封装
信息封装： 封装指的将对象的状态（属性）和行为（方法）捆绑为一个逻辑单元的机制
目的：
(1) 隐藏一个类的实现细节
(2) 防止对封装数据的未授权访问
(3) 有利于保持数据的完整性
(4) 便于修改增加了代码可维护性
案例3 ：设置手机属性，能够屏蔽非法设置
11） java 源文件结构
|
1
2
3
|
[<package_declaration>]
[<import_declaration>]
<class_declaration>+
|
|
|
案例4： 构造带有main 方法PackageTest 类，打包在cn.com.farsight;中 ，在当前目录和cn.com.farsight下执行
（1）在当前目录运行
Java cn.com.farsight.PackageTest
（2）包目录下运行
Java –cp 包的相对根目录/
cn.com.farsight.PakckageTest
注意： 打包操作不仅仅是将包放在打包目录下，此时类的名字也改变了，运行时应该指定完整的包名
12） package (打包) 和 import(导包)
（1）package 用法
语法： packet <top_pkg_name>[.<sub_pkg_name>]*;
作用：可以解决java开发中的类命名冲突问题
案例：
|
1
2
3
4
|
package cn.com.farsight;
public class Mobie{
.....
}
|
javac -d destpath Mobie.java //编译后会自动在destpath 下新建cn\com\farsight ，并将生成的class 文件都放在 cn\com\farsight
下
如果在当前目录下执行： java cn.com.farsight.Mobile
注意： 命名的规范，你的命名要具备可读性，给人传递一些信息；
例证： 比如你给孩子取名字，如：“李天一”，给人感觉—天人合一，非常好，我这采用的是域名的倒置，因为域名具有唯一性，这样做就可以避免和别人命名重复了
（2）import 用法
|
1
2
|
import <pkg_name>.[.<sub_pkg_name>].<class_name>;
import <pkg_name>.[.<sub_pkg_name>].*;
|
作用： 导入不同包中的类
注意：编译器如何找到指定包中的类
（I）在CLASS_PATH 指定的路径下面找
（II）默认情况下，系统会自动引入java.lang 中的类
案例5：构造带有main 方法MobileTest 类，导入 list , io，cn.com.farsight 工具包（）, 在当前编译运行
案例5： 自己构造类Mobile,打包在cn.com.farsight ;在类MobileTest中导入该包，当前目录编译运行。
13）java 中一些常用的包
java.lang ==> 包含一些java 语言的核心类，如String、Math、Integer、System和Thread， 提供常用的功能，不需要再程序中显示导入
javax.sql ==>提供使用java编程语言访问并处理存储在数据源(通常是一个关系型数据库)中的数据的API
java.net ==>包含与网路相关操作的类
java.io ===>包含能提供多种输入输出功能和文件操作的类
java.util===>包含一些使用工具类，如定义系统特性、使用日期日历相关的函数、集合类等
这里：可以追一下源码包的相关的类
课外练习：
作业设计：
1. 用三种方式构造方式描述学生信息（无参数的，三个参数的，两个参数的构造方式）
2.写一个员工类：Employee ，每个员工有以下属性
姓名，员工号，性别，工作年限，
级别：3级：每一级薪水增加5% * （4 – band）
薪水
增加对应的getter 和 setter的构造方法，
员工类有以下方法：
打印员工的基本信息，
打印薪水：薪水和工作年数及级别有关
编写对应的测试类EmployeeTest
源码Demo：
| |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
案例1 ：
/**
* 设置成员变量的值,并且访问
*/
class Mobile{
int weight = 100; // 设置成员属性
String brand = "Samsung";
String type = "SmartPhone";
String model = "Cdma/Gsm";
}
public class MobileTest1{
public static void main(String [] args){
Mobile m = new Mobile();
m.weight = 100 ; //设置成员变量属性
System.out.println("the weight of the Mobile : " + m.weight);
System.out.println("the brand of the Mobile : " + m.brand);
System.out.println("the type of the Mobile : " + m.type);
System.out.println("the model of the Mobile : " + m.model);
}
}
案例2 ：
/**
* 创建构造器，构造对象
*/
class Mobile{
String brand ;
String type = "SmartPhone";
String model ;
int weight ;
Mobile(String _brand,String _model){ //带两个参数的构造器
brand = _brand;
model = _model ;
}
public void show(){
System.out.println("brand = "+brand + " type = "+ type +" weight= " + " model "+ model
);
}
}
public class MobileTest{
public static void main(String [] args){
Mobile m = new Mobile("ZTE","GSM");
m.show();
}
}
案例3 ：
/**
* 信息隐藏与封装
*/
class Mobile{
private String brand ;
private String type = "SmartPhone";
private String model ;
private int weight ;
Mobile(String _brand,String _model){ //带两个参数的构造器
brand = _brand;
model = _model ;
}
void setWeight(int _weight){
if(_weight <= 0)
return ;
weight = _weight;
}
public void show(){
System.out.println("brand = "+brand + " type = "+ type +" weight= "+ weight + " model "+
model );
}
}
public class MobileTest{
public static void main(String [] args){
Mobile m = new Mobile("ZTE","GSM");
m.show();
//weight =200 ; // 不允许操作
m.setWeight(300);
m.show();
}
}
案例4 ：
/**
* 测试package 打包操作
*/
package cn.com.farsight ;
public class PackageTest {
public static void main(String [] args)
{
System.out.println("package success!!!!\n");
}
}
1）在当前目录运行
Java cn.com.farsight.PackageTest
|
2）包目录下运行
Java –cp 包的相对根目录/ cn.com.farsight.PakckageTest
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
案例5 ：
/***
* 测试倒包 Mobile.java
*/
package cn.com.farsight ; // Mobile 打包成cn.com.farsight.Mobile 类在cn\com\farsight\目录下
public class Mobile{
private String brand ;
private String type = "SmartPhone";
private String model ;
private int weight ;
public Mobile(String _brand,String _model){ //带两个参数的构造器
brand = _brand;
model = _model ;
}
public void setWeight(int _weight){
if(_weight <= 0)
return ;
weight = _weight;
}
public void show(){
System.out.println("brand = "+brand + " type = "+ type +" weight= "+ weight + " model "+
model );
}
}
1)javac –d . Mobile.java // 生成cn.com.farsight.Mobile.class 存放在 cn\com\farsight\
/**
* 测试导包，MobileTest.java
*/
import java.io.*; // IO 相关的包
import java.util.*; // 工具包
//package cn.com.farsight ;
import cn.com.farsight.Mobile;
public class MobileTest{
public static void main(String [] args){
FileInputStream fp ; //文件输入流
List owner ;
// 调用 cn.com.farsight.Mobile类，如果不想用import 则可以直接使用 上述类的全称
Mobile m = new Mobile("ZTE","GSM");
m.show();
//weight =200 ; // 不允许操作
m.setWeight(300);
m.show();
}
}
|
2)当前目录编译运行 MobileTest.java
3) 若不适用import cn.com.farsight.Mobile ; 将 Mobile 替换为cn.com.farsight.Mobile ，编译运行正常通过
4）若不在当前目录编译运行
编译： javac -cp 打包的相对根目录 .java 文件路径
运行： Java –cp 类所在目录 类名
注意： -cp / -classpath 指定的是.class 路径而不是 .java 路径
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
作业1：
/**
* 三种方式构造学生类
*/
class Student{
private String name ;
private int id ;
private int score ;
public Student() // 无参构造器
{
this("james",1000,100);
}
public Student(String _name,int _id){ // 二参构造器
this(_name,_id,0);
}
public Student(String _name ,int _id,int _score) //三参构造器
{
name = _name;
id = _id;
score = _score;
}
void show(){
System.out.println("name= "+name + " id= "+ id + " score= " + score);
}
}
public class StudentTest{
public static void main(String [] args)
{
Student s = new Student("lily",2000,99);
s.show();
Student p = new Student();
p.show();
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
|
作业2 ：
/**
*javadoc 演示程序<b> JavaDoc</b>
*@author xiaopangzi313
*@version 1.0 2014/03/12
*@测试员工信息
*/
class Employee{
private String name; //员工信息属性
private int id ;
private char sex;
private int workexperience;
private int band;
private int salary;
/**
* 员工类构造器
*/
public Employee(){
name = "zhang";
id= 128;
sex = 'f';
workexperience = 3;
band = 3;
salary = 3000 ;
}
/**
* 获取员工信息
*/
public void getter()
{
System.out.println(" name= "+name + " id = "+id + " sex = "+
sex + " workexperience = " + workexperience +
" band = "+band + " salary = "+salary );
}
/**
* 设置员工信息
*/
public void setter(String _name, int _id, char _sex,int _workexperience,int _band)
{
name = _name;
id = _id;
sex = _sex;
workexperience = _workexperience;
band = _band;
salary += salary *(int )(5.0 / 100 *(4 - band));
}
}
public class EmployeeSum{
public static void main(String [] args)
{
Employee e = new Employee();
e.getter();
e.setter("li",3000,'m',4,2);
e.getter();
}
}
|
|
用户点评