Java入门学习，java入门
分享于 点击 44919 次 点评：152
Java入门学习，java入门
Dos下常用命令
Linux常用的系统
stackoverflow
关于Java的特点和jdk、jre的说明
计算机中常用的进制转换
keyword关键字
[标识符]
整数
Java是强类型语言
Java中的8种基本数据类型
类型转换
函数
重载
数组
内存结构
面向常见简称
封装
Java中的包
Java中的访问修饰符
Java中的this关键字
Java中的内部类
关于匿名内部类
Java中的成员内部类
Java中的静态内部类
Java中的方法内部类
Java中的继承
Java中的方法的重写
继承的初始化顺序
Java中final关键字的使用
Java中的super关键字
Java中的Object类
类对象和类的对象的区别
多态
引用类型转换
关于Java中length和length()的区别
Java中的抽象类
Java中的接口
UML简介
windows10-64
cmd: //命令行
cmd:help //看命令行下的帮助
cmd:start /? //查看命令的帮助
cmd:mspaint //打开画图
affinity 亲和力
例如:(我的cpu是8个核)
希望设置记事本的相关性是占用cpu中间的4个核，用16进制来设置。
00111100 换成10进制是60，转换成16进制是3c
进入cmd(命令行模式):start /affinity 3c notepade
打开任务管理器，找到详细信息中的该进程右键设置相关性，cpu核的位置已经改变成中间的四个核。
Dos下常用命令
cls // 清屏
mkdir // 创建目录
dir // 查看文件夹(目录)
dir /w // 宽屏显示
dir /p // 分页显示
. // 当前目录
cd // 改变目录
.. // 上一级目录
d: // 切换盘符
del // 删除
del /F // 删除 f:force,强制 p：提示
del /s/F/Q // 删除子目录下文件,安静、强制、递归、通配
del * // 删除所有文件
mkdir // 创建目录 等价于 md
rmdir /？ // 删除目录的命令 等价于 rd
rmdir /s/Q // 删除目录和文件 s:删除文件 Q：安静模式 没有提示
echo xx // 输出一段文本
echo xx > a.text // 重定向输出到文本中(覆盖)
echo xx >> a.text // 重定向输出到文本中(追加)
type a.text // 显示文本的内容
tree // 显示目录的树形图
Linux常用的系统
CentOS
Ubuntu
suse
redhat
stackoverflow
IT界查询问题的网站
堆栈溢出网站 打绿色勾的答案都没有问题
分布式：由分布在不同主机上的进程协同在一起，才能构成整个应用。
J2EE // Java企业版
// 分布式企业级应用的规范
J2SE // Java标准版
J2ME // Java微型版
Java5.0 版本后，更名为JavaEE、JavaSE、JavaME
一类、公司做规范
二类、公司做产品
三类、公司做项目
关于Java的特点和jdk、jre的说明：
跨平台(操作系统)：一次编译，到处执行。
---------------------------
通过Java语言编写的应用程序在不同的系统平台上都可以运行。
原理是什么：
------------------------------
只要在需要运行Java应用程序的操作系统上，先安装一个Java虚拟机即可(JVM)。
由JVM来负责Java程序在该系统中的运行。
因为有了JVM，所以同一Java程序在不同的操作系统中都可以执行。这样就实现了Java程序的跨平台性。
也称Java具有了可移植性。
JRE: JVM + 核心类库
--------------------
Java Runtime Environment Java运行环境
包括Java虚拟机(jvm)和Java程序所需要用的核心类库等，
运行开发好的Java程序，计算机只需要安装Jre就可以了。
JDK: JRE + tool。
------------------------
Java Development kit Java开发工具包
JDK是提供给Java开发人员使用的，其中包含了java的开发工具，
也包含了JRE。所以安装了JDK，就不用在单独安装JRE了。
其中的开发工具：编译工具(javac.exe) 打包工具(jar.exe)
简单地说：使用JDK开发完成的java程序交给jre去运行。
面向对象的三个特征：封装、继承、多态。
计算机中常用的进制转换：
1byte = 8bit
1024byte = 1KB
1024K = 1M
1024M = 1G
1024G = 1T
1024T = 1P
1024P = 1E
1024E = 1Z
1024Z = 1Y
keyword关键字：
[数据类型]
class // 类
interface // 接口
byte // 字节
short // 短整型 2byte
int // 整型 4
long // 长整型 8
float // 浮点型 4
double // 双精度浮点型 8
char // 字符 2
boolean // 布尔值 true false
void // 空
[数据类型值]
true
false
null // 空，不存在
[流程控制]
...
[权限修饰符]
...
[函数、变量、类的修饰符]
abstract // 抽象的
final // 最终的
static // 静态的
synchronized // 同步
[类之间修饰]
extends // 继承、扩展
implements // 实现
[创建对象]
new // 新建
this // 这个
super // 父代
instanceof // 谁的实例
[异常]
try // 尝试
catch // 捕获
finally // 最终
throw // 抛
throws // 抛
[包]
package // 包
import // 导入
[other]
native // 本地的
transient // 临时的
[标识符]
字符 + 数字 + _ + $
// 不能以数字开头
// 不能用关键字
1、所有的包小写
2、类 + 接口 ： 单词每个首字母大写，HelloWorld
3、函数名：第一个字母小写：sayHelloWorld
4、常量名词单词全部大写
常量注意：null也是常量
整数：
1、10进制数
int age = 100;
2、8进制数
int age = 0100;
3、16进制数
int age = 0x100
Java是强类型语言：
每一种数据在使用之前必须定义数据类型。
变量的使用：变量的作用范围(一对{}之间有效)
初始化值
Java中的8种基本数据类型：
byte // -128 ~ 127
short //
int //
long //
float //
double //
char //
boolean //
[引用数据类型]
类、接口、数组
类型转换：
小数转大数自动转换(称为隐式转换)
大数转小数要强制转换(称为显式转换)
函数：
定义：
函数就是定义在类中的具有特定功能的一段独立小程序。
函数也称为方法。
特点：
*定义函数可以将功能代码进行封装
*便于对该功能进行复用
*函数只有被调用才会被执行
*函数的出现提高了代码的复用性
*对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。
注意：
函数中只能调用函数，不可以在函数内部定义函数。
定义函数时，函数的结果应该返回给调用者，交由调用者处理。
重载：
概念：
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
----------------------------------
特点：
与返回值类型无关，只看参数列表。
----------------------------------------
好处：
方便于阅读，优化了程序设计。
示例：
//返回两个整数的和
int add(int x,int y){
return x+y;
}
//返回三个整数的和
int add(int x,int y,int z){
return x+y+z;
}
//返回两个小数的和
double add(double x,double y){
return x+y;
}
数组：
概念：
同一种类型数据的集合。其实数组就是一个容器。
好处：
可以自动给数组中的元素从0开始编号，方便操作这些元素。
格式1：
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
示例：int[] arr = new int[5];
格式2：
元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
int[] arr = new int[]{3,5,1,7};
int[] arr = {3,5,1,7};
内存结构：
Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，
有对空间进行了不同区域的划分，因为每一片区域都有特定的处理
数据方式和内存管理方式。
栈内存：
用于存储局部变量，当数据使用完，所占空间会自动释放。
堆内存：
数组和对象，通过new建立的实例都存放在堆内存中。
每一个实体都有内存地址值。
实体中的变量都有默认初始化值。
实体不在被使用，会在不确定的时间内被垃圾回收器回收。
数组常见异常：
数组脚标越界异常(ArrayIndexOutOfBoundsException)
int[] arr = new int[2];
System.out.println(arr[3]);
访问到了数组中的不存在的脚标时发生。
空指针异常(NullPointerException)
int[] arr = null;
System.out.println(arr[0]);
arr引用没有指向实体，却在操作实体中的元素时。
面向常见简称：
OOP：
oriented object program 面向对象编程
OOA：
oriented object analyze 面向对象分析
OOD：
oriented object design 面向对象设计
封装：
定义：
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通
过该类提供的方法来实现对隐藏信息的操作和访问。
好处：
a、只能通过规定的方法访问数据
b、隐藏类的实例细节，方便修改和实现
封装的实现步骤：
修改属性的可见性：设为private
创建getter/setter方法：用于属性的读写
在getter/setter方法中加入属性控制语句：对属性值的合法性进行判断。
Java中的包：
1、包的作用
管理Java文件
解决同名文件冲突
2、定义包时包名之间用.来隔开
3、系统中的包
java.功能类
java.lang.(类) 包含java语言基础类
java.util.(类) 包含java语言中的各种工具类
java.io.(类) 包含输入、输出相关功能的类
4、包的使用：
(1)可以通过import关键字，在某个文件使用其它包中的类。
例：import com.thisbao.leiming
Java中的访问修饰符：
访问修饰符-可以修饰属性和方法的访问范围。
访问修饰符 本类 同包 子类 其他
private √
默认 √ √
protected √ √ √
public √ √ √ √
Java中的this关键字：
1、this关键字代表当前对象
this.属性 操作当前对象的属性
this.方法 调用当前对象的方法
2、封装对象的属性的时候，经常会使用this关键字
Java中的内部类：
定义：
内部类(Inner Class)就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。
作用：
1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据
3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便
内部类的分类：
*成员内部类
*静态内部类
*方法内部类
*匿名内部类
//外部类HelloWorld
public class HelloWorld {
// 内部类Inner，类Inner在类HelloWorld的内部
public class Inner {
// 内部类的方法
public void show() {
System.out.println("welcome to imooc!");
}
}
public static void main(String[] args) {
// 创建外部类对象
HelloWorld hello = new HelloWorld();
// 创建内部类对象
Inner i = hello.new Inner();
// 调用内部类对象的方法
i.show();
}
}
关于匿名内部类：
创建格式：
new 父类构造器（参数列表）|实现接口（）
{
//匿名内部类的类体部分
}
使用匿名内部类我们必须要继承一个父类或者实现一个接口，
当然也仅能只继承一个父类或者实现一个接口。同时它也是没有class
关键字，这是因为匿名内部类是直接使用new来生成一个对象的引用。
当然这个引用是隐式的。
public abstract class Bird {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public abstract int fly();
}
public class Test {
public void test(Bird bird){
System.out.println(bird.getName() + "能够飞 " + bird.fly() + "米");
}
public static void main(String[] args) {
Test test = new Test();
test.test(new Bird() {
public int fly() {
return 10000;
}
public String getName() {
return "大雁";
}
});
}
}
public abstract class Bird {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public abstract int fly();
}
public class Test {
public void test(Bird bird){
System.out.println(bird.getName() + "能够飞 " + bird.fly() + "米");
}
public static void main(String[] args) {
Test test = new Test();
test.test(new Bird() {
public int fly() {
return 10000;
}
public String getName() {
return "大雁";
}
});
}
}
Output输出：
大雁能够飞 10000米
Java中的成员内部类：
//外部类
public class Outer{
private int a = 99;//外部类的私有属性
//内部类Inner
public class Inner{
int b = 2; // 内部类的成员属性
public void test(){
System.out.println("访问外部类中的a:"+a);
System.out.println("访问内部类中的b:"+b);
}
}
//测试成员内部类
public static void main(String[] args){
Outer o = new Outer(); //创建外部类对象，对象名为o
Inner i = o.new Inner(); //使用外部类对象创建内部类对象，对象名为i
i.test(); //调用内部类对象的test方法
}
}
运行结果：
访问外部类中的a：99
访问内部类中的b：2
成员内部类的使用方法：
1、 Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，
Inner 类可以使用任意访问控制符，如 public 、 protected 、 private 等
2、 Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据，而不受访问
控制符的影响，如直接访问 Outer 类中的私有属性a
3、 定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去
new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );
4、 编译上面的程序后，会发现产生了两个 .class 文件
注意：
1、 外部类是不能直接使用内部类的成员和方法滴
可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。
2、 如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的
成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。
Java中的静态内部类：
概念：静态内部类是 static 修饰的内部类，
这种内部类的特点是：
1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问
2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；
如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员
3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();
//外部类
public class HelloWorld {
// 外部类中的静态变量score
private static int score = 84;
// 创建静态内部类
public static class SInner {
// 内部类中的变量score
int score = 91;
public void show() {
System.out.println("访问外部类中的score：" + HelloWorld.score);
System.out.println("访问内部类中的score：" + score);
}
}
// 测试静态内部类
public static void main(String[] args) {
// 直接创建内部类的对象
SInner si = new SInner();
// 调用show方法
si.show();
}
}
结果：
访问外部类中的score：84
访问内部类中的score：91
Java中的方法内部类：
方法内部类就是内部类定义在外部类的方法中，
方法内部类只在该方法的内部可见，即只在该方法内可以使用。
特别注意：
由于方法内部类不能在外部类的方法以外的地方使用，
因此方法内部类不能使用访问控制符和 static 修饰符。
例如：
//外部类
public class test2 {
//外部类中的方法
public void show(){
final int a = 25; //常量
int b = 13; //变量
// 方法的内部类
class MInner{
int c = 2;
//内部类中的方法
public void print(){
System.out.println("访问外部类中的常量a:"+a);
System.out.println("访问内部类中的变量c:"+c);
}
}
// 创建内部类对象
MInner min = new MInner();
// 调用内部类中的方法
min.print();
}
//测试方法的内部类
public static void main(String[] args) {
// 创建外部类对象
test2 mo = new test2();
//调用外部类的方法
mo.show();
}
}
Java中的继承：
1、概念
继承是类与类的一种关系。父类也叫基类，子类也叫派生类。
注：Java中的继承是单继承的。
2、继承的好处
子类拥有父类的所有属性和方法。
实现代码的复用，所以父类不可以使用private来修饰
3、语法规则
class 子类 extends 父类{
}
例：
public class father {
public int eye = 2;
public int mouth = 1;
public void eat(){
System.out.println("父类具有吃的能力");
}
}
public class son extends father {
}
public class test2 {
public static void main(String[] args) {
son s = new son();
System.out.println("眼睛：" + s.eye + "嘴：" + s.mouth);
s.eat();
}
}
输出：
眼睛：2嘴：1
父类具有吃的能力
Java中的方法的重写：
1、概念
如果子类对继承父类的方法不满意，是可以重写父类继承的方法的，当
调用方法时会优先调用子类的方法。
2、语法规则
a、返回值类型要与父类相同
b、方法名要与父类相同
c、参数类型及个数要与父类相同
都要与父类继承的方法相同，才叫方法的重写。
继承的初始化顺序：
1、初始化父类再初始化子类
2、先执行初始化对象中的属性，在执行构造方法中的初始化。
初始化顺序：
父类对象->父类属性初始化->父类的构造方法->子类对象->子类属性初始化->子类构造方法
Java中final关键字的使用：
final修饰的类，则该类不允许被继承
final修饰的方法，则该方法不允许被覆盖(重写);
final修饰的属性：
则该类的属性不会进行隐式的初始化(类的初始化属性必须有值)或在构造方法中赋值(但只能选其一)
final修饰变量，则该变量的值只能赋一次值，即变为常量。
Java中的super关键字：
在对象的内部使用，可以代表父类对象。
1、访问父类的属性 super.age
2、访问父类的方法 super.eat()
子类的构造的过程当中必须调用其父类的构造方法。
如果子类的构造方法中没有显示调用父类的构造方法，则系统是默认调用父类无参的构造方法。
如果显示的调用构造方法，必须在子类的构造方法的第一行。
如果子类的构造方法中既没有显示调用父类的构造方法，而父类又没有无参的构造方法，则编译出错。
Java中的Object类：
Object类是所有类的父类，如果一个类没有使用extends关键字明确标识继承另外一个类，那么这个类默认继承Object类。
1、toString()方法
在Object类里面定义toString()方法的时候返回的对象的哈希code码(对象地址字符串)
可以通过重写toString()方法表示出对象的属性
2、equals()方法名要与父类相同
比较的是对象的引用是否指向同一块内存地址
一般情况下比较两个对象时比较他的值是否一致，所以要进行重写。
类对象和类的对象的区别：
类对象关注的是类的属性 getClss
类的对象关注的是类的属性的值 obj.getClss
多态：使用多态时一定要有继承关系
1、引用多态
父类的引用可以指向本类的对象
父类的引用可以指向子类的对象
2、方法多态
创建本类对象时，调用的方法为本类方法。
创建子类对象时，调用的方法为子类重写的方法或者继承的方法。
引用类型转换：
1、向上类型转换(隐式/自动类型转换),是小类型到大类型的转换
2、向下类型转换(强制类型转换),是大类型到小类型
3、instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题
返回的是一个布尔值
关于Java中length和length()的区别：
在java中String类可以定义字符串变量和字符串数组，length()用于求String字符串对象的长度，而length用
于求String字符串数组的长度。
length()是求String字符串对象中字符的个数，而length是求字符串数组中有多少个字符串。
Java中的抽象类：
1、语法定义：
抽象类前使用abstract关键字修饰，则该类为抽象类。
2、应用场景：
a、在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。
b、从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。
3、作用：
限制规定子类必须实现某些方法，但不关注实现的细节。
4、使用规则：
a、abstract定义抽象类
b、abstract定义抽象方法，只是声明，不需要实现
c、包含抽象方法的类是抽象类
d、抽象类中可以包含普通的方法，也可以没有抽象方法
e、抽象类不能直接创建，可以定义引用变量
注：抽象方法没有方法体以分号结束
Java中的接口：接口中不能有方法体
1、概念
接口可以理解为一种特殊的类，由全局常量和公共的抽象方法所组成。
类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些
类里方法的实现细节，它只规定这些类里必须提供某些方法。
2、接口定义：
和类定义不同，定义接口不再使用class关键字，而是使用interface关键字。
3、语法格式
修饰符 [默认含有abstract关键字] interface 接口名 [extends 父接口1。。。。]{
}
接口就是用来被继承、被实现的、修饰符一般建议用public
注：
不能使用private和protected修饰接口
接口定义：
常量：接口中的属性是常量，即使定义时不添加
public static final 修饰符，系统也会自动加上。
方法：接口中的方法只能是抽象方法，总是使用，即使定义时不添加public abstract修饰符，
系统也会自动加上。
4、使用接口：
一个类可以实现一个或多个接口，实现接口使用implements关键字。Java中一个类只能继承一个父类，是
不够灵活的，通过实现多个接口可以做补充。
注意：如果要继承父类，继承父类必须在实现接口之前。
接口在使用过程中，还经常与匿名内部类配合使用。
匿名内部类就是没有名字的内部类，
多用于关注实现而不关注实现类的名称。
UML简介：
1、UML概念
Unified Modeling Language(UML)又称统一建模语言或标准建模语言。
2、常用UML图
(1)用例图(The Use case Diagram)
用例图能够以可视化的方式，表达系统如何满足收集的业务规则，以及特定的用户需求等信息。
(2)序列图(The Sequence Diagram)
序列图用于按照交互发生的一系列顺序，显示对象之间的这些交互。
(3)类图(The Class Diagram)
UML类图、业务逻辑和所有支持结构一同被用于定义全部的代码结构。
3、UML建模工具
Visio、Rational Rose、PowerDesign三种建模工具应用最广
相关文章
- 暂无相关文章
用户点评