发表于

1.(单选题)Outer类中定义了一个成员内部类Inner，需要在main()方法中创建
Inner类实例对象，以下四种方式正确的是（ ）。
A.Inner in = new Inner();
B.Inner in = new Outer.Inner();
C.Outer.Inner in = new Outer.Inner();
D.Outer.Inner in = new Outer().new Inner();
【正确答案】D
【答案解析】本题考查静态方法创建实例内部类对象 内部类的最重要的一个特点就是它可以直接访问它外部类的成员变量。成员变量是 对象身上的。对象创建完成了,才会为成员变量分配空间。能调用成员变量, 意味着一定有了实例对象. main方法是静态的，它执行的时候可以不用创建那个对象。这就矛盾了。 main方法运行的时候没有任何外部类的实例对象。我们的内部类的实例对象创建了 它又可以访问外部类的成员变量，外部类的实例对象在哪儿了？ 所以这个原因，要想创建内部类的实例对象，必须创建外部类的实例对象 选项D正确。

2.(单选题)下列运算结果正确的是（ ）。
A.int x = 4590;
x = x / 1000 *1000;
x的结果是4590
B.int x = 3;
x = x++;
x的结果是4
C.short x = 3;
x = x+4;
x的结果是7
D.int x = 2;
boolean b = x>3 && x<6;
b的结果是false
【正确答案】D
【答案解析】本题考查运算符的使用 选项A，java中整数的直接量都是int类型，两个整型相除，忽略余数，结果还是int类型，4590/1000结果是4,41000=4000，结果为4000，错误 选项B，程序的执行顺序先运算赋值运算，变量再自增，所以x的结果是3 选项C，编译错误

3.(单选题)下列程序输出结果是（ ）。
class Super {
public static void m1() {
System.out.println(“m1 in Super”); }
public void m2() {
System.out.println(“m2 in Super”); }}
class Sub extends Super {
public static void m1() {
System.out.println(“m1 in Sub”); }
public void m2() {
System.out.println(“m2 in Sub”); }}
public class TestMain {
public static void main(String args[]) {
Super sup = new Sub();
sup.m1();
sup.m2();
Sub sub = (Sub) sup;
sub.m1();
sub.m2(); }}
A.m1 in Sub
m2 in Sub
m1 in Sub
m2 in Sub
B.m1 in Super
m2 in Super
m1 in Sub
m2 in Sub
C.m1 in Sub
m2 in Sub
m1 in Super
m2 in Super
D.m1 in Super
m2 in Sub
m1 in Sub
m2 in Sub
【正确答案】D
【答案解析】静态方法可以被继承和隐藏 而不能够被重写，因此不能实现多态，不能实现父类的引用可以指向不同子类的对象进行多态调用。 选项D正确

4.(多选题)请选出属于JDK的组成部分（ ）。
A.支持JAVA程序运行的一组类库
B.JVM
C.支持JAVA程序开发的一组开发工具
D.一组软件测试工具
【正确答案】A,B,C
【答案解析】JDK：JAVA开发工具集，包含JAVA程序的运行环境和辅助JAVA开发的一组开发工具。运行环境又包括一组类库和JVM

5.(多选题)下面关于数组的说法中，正确的是（ ）。
A.在类中声明一个整数数组作为成员变量，如果没有给它赋值，数值元素值为空
B.数组可以在内存空间连续存储任意一组数据
C.数组必须先声明，然后才能使用
D.数组本身是一个对象
【正确答案】C,D
【答案解析】本题考查数组的基本使用 数组中元素如果是数值元素初值为0值，数组中元素类型必须一致，数组必须先声明 再使用，数组在内存中以对象的形式存在。选项CD正确。

6.(多选题)下列关于JDK的说法正确的是（ ）
A.开发一个Java程序，需要完整的JDK
B.运行一个Java程序，需要完整的JDK
C.运行一个Java程序，只需要JDK中的JRE
D.以上说法都不对
【正确答案】A,C
【答案解析】本题考查JDK的组成和每个组成部分的功能 JDK是Java语言的软件开发工具包，其中包括JRE和一组开发工具 选项A，开发一个JAVA程序，需要开发工具，所以需要完整的JDK，正确 选项B，运行一个Java程序只需要JRE 错误 选项C，运行一个Java程序，只需要JDK中的JRE 正确 选项D，A C 选项是正确的，所以该选项是错误的

7.(多选题)给定java代码如下所示，在1处新增下列（ ）方法，是对show方法的重载
public class Test{
public void show(int x, int y, int z) { }
//1
}
A.public int show(int x,int y,float z){return 0;}
B.public int show(int x,int y,int z){return 0;}
C.public void show(int x,int z){}
D.public viod show(int z,int y,int x){}
【正确答案】A,C
【答案解析】本题考查方法的重载规则 方法的重载必须满足方法名相同和参数不同（类型或个数） 选项AC满足重载的条件正确 选项BD参数都与定义的方法参数相同，不是重载。

8.(多选题)给出以下代码，请问该程序的运行结果是什么？
class A{
private int x=0;
static int y=1;
protected int z=2;
}
class B extends A{
void method(){
System.out.println(x);
System.out.println(y);
System.out.println(z);
}
}
下列说法正确的是（ ）。
A.程序编译错误，因为类B不能访问变量x。
B.程序编译成功，打印输出012。
C.程序编译错误，如果移走System.out.println(x)这条语句，
可使编译程序通过。
D.程序编译错误,因为变量x未在类B中定义。
【正确答案】A,C,D
【答案解析】本题考查java中几种访问修饰符 public：公共的，可以在任何类中访问 protected：受保护的，只能在同一个包中，或子类中访问 default：只能在同一个包中的类中访问 private:私有的，只能在本类中访问的 本题代码中，变量x是私有的，不能在类外部访问，ACD正确。

9.(多选题)关于类、对象、引用以下描述正确的是（ ）。
A.Person person = new Person(“张三”);
person是一个对象，是内存中的一块区域，是Person类的一个实例
B.Person person = new Person(“张三”);
person并不是真正的对象，而是指向所创建的对象的引用
C.Person person;
person = new Person(“张三”);
person = new Person(“李四”);
person是引用类型的变量，指向了“张三”和“李四”两个对象
D.Person person;
person = new Person(“张三”);
person = new Person(“李四”);
person是引用类型的变量，最后指向了“李四”这个对象
【正确答案】B,D
【答案解析】本题考查引用类型变量的含义 引用类型的变量可以存放该类对象的地址信息，通常称为“指向该类对象”； 选项A和B中，person并不是所创建的对象，是一个引用，是一个可以指向Person类的对象的引用。真正创建对象的语句是右边的new Person(“张三”); A错误，B正确 选项C和D，这里让person先指向了“张三”这个对象，然后又指向了“李四”这个对象。也就是说，Person person，这句话只是声明了一个Person类的引用，它可以指向任何Person类的实例 A错误，D正确

10.关于垃圾收集的哪些叙述是对的？（ ）

  • A．垃圾收集将检查并释放不再使用的内存。
  • B．垃圾收集允许程序开发者明确指定并立即释放该内存。
  • C．程序开发者必须自己创建一个线程进行内存释放的工作。

  • D．垃圾收集能够在期望的时间释放被 Java 对象使用的内存。
    【参考答案】A

  • 【试题分析】Java 语言将内存分配和释放的工组交给了自己，程序员不必做这些工作，它提供一个系统级的线程跟踪每个内存的分配，在 JVM 的空闲处理中，垃圾收集线程将检查和释放不再使用的内存（即可以被释放的内存）。垃圾收集的过程在 Java 程序的生存期中是自动的，不需要分配和释放内存，也避免了内存泄漏。可以调用 System.gc()方法建议 JVM 执行垃圾收集以使得可被释放的内存能立即被使用，当此方法返回的时候， JVM 已经做了最大的努力从被丢弃的对象上回收内存空间。程序员不能指定收集哪些内存，一般而言也不用关心这个问题，除非是程序的内存消耗很大，特别是有很多临时对象时可以“建议“进行垃圾收集以提高可用内存。需要指出的是调用 System.gc()方法不能保证 JVM 立即进行垃圾收集，而只能是建议,因为垃圾收集线程的优先级很低（通常是最低的）。JVM 垃圾收集器收集一个对象之前，一般要求程序调用适当的方法释放资源，但在没有明确释放资源的情况下，Java 提供了缺省机制来终止化该对象心释放资源，这个方法就是 finalize( )。因此选项 A是正确的。

  • 垃圾收集器不可以被强制执行，但程序员可以通过调用 System. gc 方法来建议执行垃圾收集器。因此选项 B 是错误的。
  • Java 的垃圾回收机制是为所有 Java 应用进程服务的，而不是为某个特定的进程服务的。因此，任何一个进程都没有权利去命令垃圾回收机制做什么、怎么做或做多少。因此选项 C 是错误的。
  • Java 运行时系统只在需要的时候才使用垃圾收集。因此用户无法知道垃圾回收发生的精确时间。同样没有办法预知在一组均符合垃圾收集器收集标准的对象中，哪一个会被首先收集。 因此选项 D 是错误的。

发表于

1.输出两个int数中的最大值

用户从控制台接收两个整数，通过程序找出两个数中的最大值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入依次输入两个整数a，b 用空格符 空开");
		int a = scan.nextInt();
		int b = scan.nextInt();
		int max = a>b?a:b;
		System.out.println(max);
		if(a>b) {
			System.out.println("最大值为："+a);
		}else {
			System.out.println("最大值为："+b);
		}

	}

2.编写三个数值的排序程序

使用程序为用户所录入的 3 个数值进行升序排列，并将排序后的结果输出到控制台。

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
public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入依次输入三个整数a，b，c 用空格符 空开");
		int a = scan.nextInt();
		int b = scan.nextInt();
		int c = scan.nextInt();
		System.out.println("您输入的是：");
		System.out.println("a="+a+",b="+b+",c="+c);
		if(a>b) {
			int d=a;
			a=b;
			b=d;
		}
		if(a>c) {
			int d=a;
			a=c;
			c=d;
		}
		if(b>c) {
			int d=b;
			b=c;
			c=d;
		}
		System.out.println("升序排序后结果为：");
		System.out.println("a="+a);
		System.out.println("b="+b);
		System.out.println("c="+c);
}

3.编写程序判断某一个年份是否为闰年（使用if-else）

本案例需要使用交互的方式判断某年是否为闰年：用户从控制台输入需要判断的年份值，由程序使用if-else判断该年是否为闰年，并将判断结果输出到控制台。

1
2
3
4
5
6
7
8
9
10
public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
		System.out.println("请输入年份：");
		int year = scan.nextInt();
		if(year%4==0 && year%100!=0 || year%400==0) {
			System.out.println(year+"是闰年");
		}else {
			System.out.println(year+"是平年");
		}
}

4.输出三个int数中的最大值

用户从控制台接收三个整数，通过程序找出三个数中的最大值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入依次输入三个整数a，b，c 用空格符 空开");
		int a = scan.nextInt();
		int b = scan.nextInt();
		int c = scan.nextInt();
		if(a>b && a>c) {
			System.out.println("最大值为a="+a);
		}else if(b>a && b>c) {
			System.out.println("最大值为b="+b);
		}else {
			System.out.println("最大值为c="+c);
		}

}

发表于

String 方法：

startsWith(String str):boolean //判断字符串是否以给定的前缀开头
endsWith(String str):boolean //判断字符串是否以给定的后缀结尾
toUpperCase(): //将字符串中所有的英文转换为大写
toLowerCase()： //将字符串中所有的英文转换为小写
valueOf(otherType):String //将其他类型的数据转换为String类型

1
2
3
4
5
6
7
8
9
   public static void main(String[] args) {
	String str = "a";
	for(int i=0;i<10000000;i++) {
		str += "a";
	}
	System.out.println("执行结束");
}
本程序存在的问题：会创建大量的对象，严重降低内存的性能
针对于大量的字符串拼接，java中提供了StringBuilder类来完成字符串的修改操作

StringBuilder

是专门设计用于做字符串修改操作的，提供了编辑字符串对应的增，删，改，插操作

1
2
3
4
5
6
7
8
9
构造方法有：
StringBuilder()
StringBuilder(String str)
方法：
append（String）//拼接字符串
delete(int start,int end) //删除从start开始到end结束的字符串
insert(int index,String str) // 将给定的字符串插入到index位置
replace(int start,int end,String str)// 使用给定的字符串替换start-end之间的字符串
reverse()// 判断回文

如果只有两个String进行拼接，”+”可以
但是如果是大量的字符串进行拼接，就应该使用StringBuilder对象
StringBuffer和StringBuilder功能相同，api的使用也是相同的，
区别在于StringBuilder是非线程安全的，StringBuffer是线程安全的

正则表达式

什么是正则：
正则是一个字符串，是用于规定字符出现次序的规则，正则是独立的一套体系，很多语言都提供了对其的支持。
java提供了一个简单的方式用于验证用户的输入内容：通过正则表达式验证

语法：

- 字符集
1. [] :匹配一位字符
2. 预定义字符集
        . 任意字符
        \d 任意数字
        \w 单词字符
        \s 空白字符
3. 数量词：
        X？ 0次或1次
        X+  出现1次以上
        X*  出现任意次
        X{n} 出现n次
        X{n,} 出现至少n次
        X{n,m} 至少出现n次，最多m次

分组(): 经常和|配合使用

- 将（）内的内容看成一个整体

注意点：

  1. java中的\和正则中的\都是转义字符，冲突，应使用\
  2. 若要使用正则中的一些特殊字符的本意，需要进行转义
  3. 通过String中的matches(regex)对字符串进行正则校验

正则表达式中若想使用一些特殊字符的本意，需要转义 \

1
2
3
4
5
6
7
特殊字符：
       .
       +
       ？
       *
      （
       {

边界匹配符：

  1. ^开头 $结尾
  2. java中的matches(regex)自带边界匹配功能，进行的完全匹配

String类中的正则api

- matches(String regex)
- split(String regex)
- replaceAll(String regex,String replacement):
                  - 实际工作中，常用于做过滤敏感字符

发表于

编写一个收银柜台收款程序。根据商品单价、购买数量以及收款金额计算并输出应收金额和找零

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
package day03;
import java.util.Scanner;
public class Cashier {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入商品单价：");
		double price = scan.nextDouble();
		System.out.println(price);

		System.out.println("请输入购买的数量：");
		int number = scan.nextInt();
		System.out.println(number);

		System.out.println("实际支付为：");
		double money = scan.nextDouble();
		System.out.println(money);

		double totalPrice = price * number;
		System.out.println("总价为：" + totalPrice);
		if (totalPrice >= 500) {
			totalPrice *= 0.8;
			System.out.println("打折后：" + totalPrice);
		}
		if (money >= totalPrice) {
			double change = money - totalPrice;
			System.out.println("最后价格为：" + totalPrice + "找零：" + change);
		} else {
			System.out.println("ERROR!您给的钱不够，" + "需要再付款：" + (totalPrice - money));
		}
	}
}

发表于

1.String： String是不可改变对象

java中规定String一旦创建就不可以改变了。

1
2
3
4
5
6
7
8
		public static void main(String[] args) {
			String str = "abc";
			str += "def";
			System.out.println(str);  //abcdef
		}
String对象创建后是不可变的，本案例是str引用指向发生了改变，
在内存中新创建了一个String对象“abcdef”,str重新指向了此对象;
原对象“abc”是没有发生改变的

2.String的本质：底层封装了一个字符数组。

String的创建:两种方式

1.String str = new String(“abc”);
通过new创建String对象，常用的构造方法有：

1
2
1. new  String(String)
2. new  String(char[])

2.String str = “hello”;
字符串字面量，是new String（””）的简写 优点：字符串字面量是被复用的

注意：

1. java中字符串字面量之间的拼接，编译器在编译期会进行优化，在.class文件中保存的是拼接后的结果
2. 字符串变量之间的拼接，编译器不会优化，底层采用new的方式创建了一个新的String对象

3.String方法操作

length():获取字符串的长度
indexOf系列：

1
2
3
indexOf(String str):int //获取指定子字符串在本字符串中第一次出现的索引
indexOf(String str,int fromIndex):int //找出字符串从指定位置开始第一次出现的下标
lastIndexOf(String str):int //获取指定字符串在当前字符串中最后一次出现的下标

substring系列：

1
2
substring(int fromIndex):String //从指定位置开始截取，直到字符串的末尾
substring(int start,int end):String //截取从两个坐标之间的字符  规则： 包头不包尾  最后坐标加1

trim():String //去掉字符串开头和结尾部分的空白

charAt() 方法用于返回指定索引处的字符。索引范围为从 0 到 length() - 1。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
判断字符串是否是回文
	String str = "上海自来水来自海上";
	boolean flag = false;
	for(int i=0;i<str.length()/2;i++) {
		char c1 = str.charAt(i);
		char c2 = str.charAt(str.length()-1-i);
		if(c1!=c2) {
			System.out.println("不是回文");
			flag = true;
			break;
		}
	}
	if(!flag) { // !flag 等同于flag为false
		System.out.println("是回文");
	}

发表于

1.package:

1)作用:避免类的命名冲突
2)包名可以有层次结构 类的全称: 包名.类名
3)同包中的类不能同名
4)建议:包名所有字母都小写

import:

1)同包中的类可以直接访问，
​ 不同包中的类不能直接访问，想访问如下两种方式:
1.先import声明类再使用类——-建议
2.类的全称—————太繁琐，不建议

2.访问控制修饰符:

1)public:公开的，任何类
2)private:私有的，本类
3)protected:受保护的，本类、派生类、同包类
4)默认的:什么也不写，本类、同包类
说明:
​ 1)类的访问控制修饰符只能是public和默认的
​ 2)类中成员的访问控制修饰符如上4种都可以

3.final:最终的、不可改变的—–单独应用率极低

1)修饰变量:变量不能被改变
2)修饰方法:方法不能被重写
3)修饰类:类不能被继承

4.static:静态的

1)静态变量:
​ 1.由static修饰
​ 2.属于类，存在方法区中，只有一份
​ 3.常常通过类名点来访问
​ 4.何时用:所有对象所共享的数据(图片、音频、视频等)
2)静态方法:
​ 1.由static修饰
​ 2.属于类，存在方法区中，只有一份
​ 3.常常通过类名点来访问
​ 4.静态方法没有隐式this传递的，
​ 在静态方法中不能直接访问实例成员
​ 5.何时用:方法的操作仅与参数相关而与对象无关时
3)静态块:
​ 1.由static修饰
​ 2.属于类，在类被加载期间自动执行，
​ 因类只被加载一次，所以静态块只执行一次
​ 3.何时用:加载/初始化静态资源(图片、音频、视频等)

5.static final常量:

1)必须声明同时初始化
2)由类名点来访问，并且不能被改变
3)建议:常量名所有字母都大写，多个单词用_分隔
4)编译器在编译时将常量直接替换为具体的值，效率高
5)何时用:数据永远不变、并且经常使用

6.抽象方法:

1)由abstract修饰
2)只有方法的定义，没有具体的实现(连{}都没有)

7.抽象类:

1)由abstract修饰
2)包含抽象方法的类必须是抽象类
​ 不包含抽象方法的类也可以声明为抽象类
3)抽象类不能被实例化
4)抽象类是需要被继承的，派生类:
​ 1.重写所有抽象方法——–常用
​ 2.也声明为抽象类——-一般不这么做
5)抽象类的意义:
​ 1.封装派生类所共有的属性和行为———代码复用
​ 2.给所有派生类提供统一的类型————向上造型
​ 3.可以包含抽象方法，为所有派生类提供统一的入口
​ 派生类的具体行为不同，但入口是一致的

8.成员内部类:应用率低

​ 问:内部类有独立的.class吗?
​ 答:有
1)类中套类，外面的称为Outer外部类，里面的称为Inner内部类
2)内部类通常只服务于外部类，对外不具备可见性
3)内部类对象通常是在外部类中创建的
4)内部类中可以直接访问外部类的成员(包括私有的)
​ 内部类中有个隐式的引用指向了创建它的外部类对象

9.匿名内部类:应用率高

1)若想创建了一个类(派生类)的对象，并且对象只被创建一次，
​ 此时该类不必命名，称为匿名内部类
2)匿名内部类中若想访问外部的变量，该变量必须是的final的
​ —–在JDK1.8之前有这样的要求

10.接口:

1)是一种数据类型(引用类型)
2)由interface定义
3)只能包含常量和抽象方法
4)接口不能被实例化
5)接口是需要被实现/继承的，实现类/派生类:
​ 必须重写接口中的所有抽象方法
6)一个类可以实现多个接口，用逗号隔开
​ 若又继承又实现时，必须先继承后实现
7)接口可以继承接口

设计规则:

1)将所有派生类所共有的属性和行为，抽到超类中——–抽共性
2)所有派生类的行为都一样，设计为普通方法
所有派生类的行为都不一样，设计为抽象方法
3)将部分派生类所共有的行为，抽到接口中
接口是对继承单根性的扩展————-实现多继承
符合 既是 也是 原则时，使用接口

11.多态:

1)意义:
​ 1.同一类型的引用，指向不同的对象时，有不同的实现
​ —-行为的多态:cut()、run()、step()、getImage()…
​ 2.同一个对象，被造型为不同的类型时，有不同的功能
​ —-对象的多态:水、我…
2)向上造型/自动类型转换:
​ 1.超类型的引用指向派生类的对象
​ 2.能造型成为的数据类型有: 超类+所实现的接口
​ 3.能点出来什么，看引用的类型
3)强制类型转换，成功的条件只有如下两种:
​ 1.引用所指向的对象，就是该类型
​ 2.引用所指向的对象，继承了该类或实现了该接口
4)强转时若不符合如上条件，则发生ClassCastException类型转换异常
​ 建议:在强转之前先通过instanceof来判断引用的对象是否是该类型

12.内存管理:由JVM来管理的

1)堆:
​ 1.存储new出来的对象(包括实例变量)
​ 2.垃圾:没有任何引用所指向的对象
​ 垃圾回收器(GC)不定时到内存中清理垃圾，
​ 回收过程是透明的(看不到的)，不一定一发现垃圾就立刻回收，
​ 调用System.gc()可以建议虚拟机尽快调度GC来回收
​ 3.内存泄漏:不再使用的内存没有被及时的回收
​ 建议:对象不再使用时及时将引用设置为null
​ 4.实例变量的生命周期:
​ 在创建对象时存储在堆中，对象被回收时一并被回收
2)栈:
​ 1.存储正在调用的方法中的所有局部变量(包括方法的参数)
​ 2.调用方法时，会在栈中为该方法分配一块对应的栈帧，
​ 栈帧中存储方法中的局部变量(包括参数)，
​ 方法调用结束时，栈帧被清除，局部变量一并被清除
​ 3.局部变量的生命周期:
​ 方法被调用时存储在栈中，方法结束时与栈帧一并被清除
3)方法区:
​ 1.存储.class字节码文件(包括静态变量、方法)
​ 2.方法只有一份，通过this来区分具体的调用对象

面向对象三大特征:

1.封装:
1)类:封装的是对象的属性和行为
2)方法:封装的是特定的业务逻辑功能
3)访问控制修饰符:封装的是具体的访问权限
2.继承:
1)作用:代码复用
2)超类:所有派生类所共有的属性和行为
​ 接口:部分派生类所共有的行为
​ 派生类:派生类所特有的属性和行为
3)单一继承、多接口实现，传递性
3.多态:
1)意义:行为的多态(所有抽象方法都是多态的)
​ 对象的多态(所有对象都是多态的)
2)向上造型、强制类型转换、instanceof判断
3)多态的表现形式:
​ 1.重写:根据对象的不同来表现多态
​ 2.重载:根据参数的不同来表现多态

发表于

1.什么是类？什么是对象？

1)现实世界是由很多很多对象组成的
​ 基于对象抽出了类
2)对象:真实存在的单个的个体
​ 类:类型/类别，代表一类个体
3)类中可以包含:
​ 1.所有对象所共有的属性/特征————成员变量
​ 2.所有对象所共有的行为——————-方法
4)一个类可以创建多个对象
​ 同一类型所创建的对象，结构相同，数据不同
5)类是对象的模板，对象是类的具体的实例

方法签名:方法名+参数列表

2.方法的重载:

1)发生在同一个类中，方法名相同，参数列表不同，方法体不同
2)编译器在编译时会根据方法的签名自动绑定调用的方法

3.构造方法:构造函数、构造器、构建器

1)给成员变量赋初值
2)与类同名，没有返回值类型
3)在创建(new)对象时被自动调用
4)若自己不写构造方法，则编译器默认一个无参构造方法，
​ 若自己写了构造方法，则不再默认提供
5)构造方法可以重载

4.this:指代当前对象，哪个对象调用方法它指的就是哪个对象

只能用在方法中，方法中访问成员变量之前默认有个this.
this的用法:
​ 1)this.成员变量名————–访问成员变量
​ 2)this.方法名()—————-调用方法(一般不用)
​ 3)this()———————–调用构造方法
成员变量和局部变量是可以同名的
——用的时候，采取的是就近原则
——此时访问成员变量是不能省略this.的

5.null:空，没有指向任何对象

若引用的值为null，则该引用不能进行任何操作了，
​ 若操作则发生NullPointerException空指针异常

6.引用类型之间画等号:

1)指向同一个对象
2)通过一个引用对象的修改会影响另一个引用的访问
基本类型之间画等号:
1.赋值
2.对一个变量的修改不会影响另一个变量

7.引用类型数组 使用:

1
2
3
4
5
6
7
8
9
10
11
12
1)Student[] stus = new Student[3]; //创建Student数组对象
   stus[0] = new Student("zhangsan",25,"LF"); //创建Student对象
   stus[1] = new Student("lisi",26,"JMS");
   stus[2] = new Student("wangwu",27,"SD");
   System.out.println(stus[0].name);
   stus[1].age = 28;
   stus[2].sayHi();
 2)Student[] stus = new Student[]{
     new Student("zhangsan",25,"LF"),
     new Student("lisi",26,"JMS"),
     new Student("wangwu",27,"SD")
   };

8.继承:

1)作用:代码复用
2)通过extends来实现继承
3)超类:派生类所共有的属性和行为
​ 派生类:派生类所特有的属性和行为
4)派生类继承超类后，派生类具有: 派生类的+超类的
5)一个超类可以有多个派生类
​ 一个派生类只能继承一个超类——单一继承
6)继承具有传递性
7)java规定:构造派生类之前必须先构造超类
​ 在派生类的构造方法中若没有调用超类的构造方法
​ —则默认super()调用超类的无参构造方法
​ 在派生类的构造方法中若调用了超类的构造方法
​ —则不再默认提供
​ super()调用超类构造方法必须位于派生类构造方法的第一行

9.super:指代当前对象的超类对象

super的用法:
1)super.成员变量名———–访问超类的成员变量
2)super.方法名()————-调用超类的方法
3)super()——————–调用超类的构造方法

10.向上造型:

1)超类型的引用指向派生类的对象
2)能点出来什么，看引用的类型

11.方法的重写(Override):重新写、覆盖

1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
2)重写方法被调用时，看对象的类型
3)遵循”两同两小一大”原则:
​ 1.两同:
1)方法名称相同
2)参数列表相同
​ 2.两小:
​ 1.派生类方法的返回值类型小于或等于超类方法的
​ 1)void时，必须相同
​ 2)基本数据类型时，必须相同
​ 3)引用数据类型时，小于或等于
​ 2.派生类方法抛出的异常小于或等于超类方法的———-异常
​ 3.一大:
​ 1)派生类方法的访问权限大于或等于超类方法的

12.重写与重载的区别:

1)重写(Override):
​ 1.发生在父子类中，方法名相同，参数列表相同，方法体不同
​ 1.”运行期绑定”，看对象的类型绑定方法
2)重载(Overload):
​ 1.发生在一个类中，方法名相同，参数列表不同，方法体不同
​ 2.”编译期绑定”，看参数/引用的类型绑定方法

发表于

循环:反复多次执行一段相同或相似的代码

1.循环三要素:

1)循环变量的初始化
2)循环的条件(以循环变量为基础)
3)循环变量的改变(向着循环的结束变)
循环变量:在整个循环过程中所反复改变的那个数

2.循环结构:

1)while结构:先判断后执行，有可能一次都不执行
2)do…while结构:先执行后判断，至少执行一次
3)for:固定次数循环，应用率最高
break:跳出循环
continue:跳过循环体中剩余语句而进入下一次循环

3.三种循环结构的更佳适用情况:

1)while:”当…”
2)do…while:”直到…”
​ 要素1与要素3相同时首选do…while
3)for:固定次数循环

4.嵌套循环:

1)循环中套循环，一般多行多列时使用，外层控制行，内层控制列
2)执行规则:外层循环走一次，内层循环走所有次
3)建议:嵌套层数越少越好，能一层就不用两层，能两层就不用三层
若业务必须通过三层以上的循环来解决，说明你的设计有问题
4)break只能跳出一层循环

5.程序=算法+数据结构

1)算法:解决问题的步骤/流程(顺序、分支、循环)
2)数据结构:将数据按照某种特定的结构来保存
数怎么存
设计良好的/合理的数据结构会导致好的算法

6.数组:

1)相同数据类型元素的集合
2)是一种数据类型(引用类型)
3)数组的定义:

1
int[] arr = new int[10];

4）数组的初始化：

1
2
3
4
5
6
int[] arr = new int[4]; //四个元素 默认值都为0
int[] arr = {1,4,6,8}; //1,4,6,8
int[] arr = new int[]{1,4,6,8}; //1,4,6,8
int[] arr;
arr = {1,4,6,8}; //编译错误，此方式只能声明同时初始化
arr = new int[]{1,4,6,8}; //正确

5）数组的访问:

1
2
3
4
5
6
7
8
9
10
11
5.1)通过(数组名.length)可以获取数组的长度(元素的个数)
    int[] arr = new int[4];
 System.out.println(arr.length); //元素个数为4个
5.2)通过下标/索引来访问数组中的元素
    下标从0开始，最大到(数组的长度-1)
 int[] arr = new int[3];
 arr[0] = 100; //给第1个元素赋值为100
 arr[1] = 200; //给第2个元素赋值为200
 arr[2] = 300; //给第3个元素赋值为300
 //arr[3] = 400; //数组下标越界异常
 System.out.println(arr[arr.length-1]); //输出最后一个元素的值

6)数组的遍历:

1
2
3
4
5
6
7
8
9
10
int[] arr = new int[10];
   for(int i=0;i<arr.length;i++){
     arr[i] = (int)(Math.random()*100);
   }
   for(int i=0;i<arr.length;i++){
     System.out.println(arr[i]);
   }
   for(int i=arr.length-1;i>=0;i--){
     System.out.println(arr[i]);
   }

7)数组的复制:

1
2
3
1)System.arraycopy(a,1,a1,0,4);
2)int[] a1 = Arrays.copyOf(a,6);
  a = Arrays.copyOf(a,a.length+1); //数组的扩容

8)数组的排序:

1
1)Arrays.sort(arr);

7.方法:函数、过程

1)封装一段特定的业务逻辑功能
2)尽可能独立，一个方法只干一件事
3)方法可以被反复多次的调用
4)减少代码的重复，有利于代码的维护，有利于团队的协作
5)方法的定义:
修饰词 返回值类型 方法名(参数列表){
方法体
}
6)方法的调用:
1)无返回值: 方法名(有参传参);
2)有返回值: 数据类型 变量 = 方法名(有参传参);
7）return 用法:
1)return; //1)结束方法的执行
2)return 值; //1)结束方法的执行 2)返回结果给调用方

byte：

  • byte 数据类型是8位、有符号的，以二进制补码表示的整数；
  • 最小值是 -128（-2^7）；
  • 最大值是 127（2^7-1）；
  • 默认值是 0；
  • byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；

short：

  • short 数据类型是 16 位、有符号的以二进制补码表示的整数
  • 最小值是 -32768（-2^15）；
  • 最大值是 32767（2^15 - 1）；
  • Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
  • 默认值是 0；

int：

  • int 数据类型是32位、有符号的以二进制补码表示的整数；
  • 最小值是 -2,147,483,648（-2^31）；
  • 最大值是 2,147,483,647（2^31 - 1）；
  • 一般地整型变量默认为 int 类型；
  • 默认值是 0 ；

long：

  • long 数据类型是 64 位、有符号的以二进制补码表示的整数；
  • 最小值是 -9,223,372,036,854,775,808（-2^63）；
  • 最大值是 9,223,372,036,854,775,807（2^63 -1）；
  • 这种类型主要使用在需要比较大整数的系统上；
  • 默认值是 0L；
  • 例子： long a = 100000L，Long b = -200000L。
    “L”理论上不分大小写，但是若写成”l”容易与数字”1”混淆，不容易分辩。所以最好大写。

float：

  • float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
  • float 在储存大型浮点数组的时候可节省内存空间；
  • 默认值是 0.0f；
  • 浮点数不能用来表示精确的值，如货币；

double：

  • double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
  • 浮点数的默认类型为double类型；
  • double类型同样不能表示精确的值，如货币；
  • 默认值是 0.0d；

boolean：

  • boolean数据类型表示一位的信息；
  • 只有两个取值：true 和 false；
  • 这种类型只作为一种标志来记录 true/false 情况；
  • 默认值是 false；

char：

  • char类型是一个单一的 16 位 Unicode 字符；
  • 最小值是 \u0000（即为0）；
  • 最大值是 \uffff（即为65,535）；
  • char 数据类型可以储存任何字符；

发表于

高质量的代码:

复用性好、扩展性好、维护性好、

可移植性好、健壮性好、可读性好、效率好…

1.Java开发环境:

1)编译运行过程:
1.1)编译期:.java源文件，经过编译，生成.class字节码文件
1.2)运行期:JVM加载.class并运行.class
特点:跨平台、一次编程到处使用
2)名词解释:
2.1)JVM:java虚拟机
加载.class并运行.class
2.2)JRE:java运行环境
除了包含JVM以外还包含了运行java程序所必须的环境
JRE = JVM+java系统类库(小零件)
2.3)JDK:java开发工具包
除了包含JRE以外还包含了开发java程序所必须的命令工具
JDK = JRE+编译、运行等命令工具
说明:
1)运行java程序的最小环境是JRE
2)开发java程序的最小环境是JDK
3)配置环境变量
3.1)JAVA_HOME:指向jdk的安装路径
3.2)CLASSPATH:表示类的搜索路径，一般简写为.
3.3)PATH:指向jdk下的bin目录

2.变量:存数的，代词，指代的就是它所存的那个数

1)声明:
2)初始化:第一次赋值
3)使用:
1)对变量的使用就是对它所存的那个数的使用
2)变量的使用必须与数据类型匹配
3)变量在用之前必须声明并初始化
4)命名:
4.1)只能包含字母、数字、_和$符，并且不能以数字开头
4.2)严格区分大小写
4.3)不能使用关键字
4.4)可以中文命名，但不建议
建议”英文的见名知意”、”驼峰命名法”

3.基本数据类型:

1)int:整型，4个字节，-21个多亿到21个多亿
1.1)整数直接量默认为int类型，但不能超范围，超范围则编译错误
1.2)两个整数相除，结果还是整数，小数位无条件舍弃(不会四舍五入)
1.3)整数运算时若超出范围会发生溢出，溢出是需要避免的
2)long:长整型，8个字节，很大很大很大
2.1)长整型的直接量，需在数字后加L或l
2.2)运算时若有可能溢出，建议在第1个数字后加L
2.3)System.currentTimeMillis() 用于获取
自 1970.1.1零时到此时此刻的毫秒数
3)double:浮点型，8个字节，很大很大很大
3.1)浮点数直接量默认为double型，若想表示float需在数字后加F或f
3.2)double和float型数据参与运算时，有可能会出现舍入误差
4)boolean:布尔型，1个字节
4.1)只能取值为true或false
5)char:字符型，2个字节
5.1)采用Unicode字符集编码，每个字符对应一个码
表现的形式是字符char，但本质上是码int(0到65535之间)
(ASCII码: ‘a’–97 ‘A’–65 ‘0’–48)
5.2)字符型直接量必须放在单引号中，只能有一个
5.3)特殊符号需要通过\来转义

4.基本数据类型间的转换:

1
2
数据类型从小到大依次为:
byte,short,char—> int —> long—> float —> double

1)两种方式:
1.1)自动类型转换:小类型到大类型
1.2)强制类型转换:大类型到小类型
语法: (要转换成为的数据类型)变量
强转有可能会发生溢出或精度的丢失
2)两点规则:
2.1)整数直接量可以直接赋值给byte、short、char，
但不能超出范围
2.2)byte、short、char型数据参与运算时，
先一律转换为int再运算

5.运算符:

1)算术运算符:+, -, *, /, %, ++, –
2)关系运算符:>, <, >=, <=, ==, != boolean
3)逻辑运算符:&&, ||, ! boolean
4)赋值运算符:=, +=, -=, *=, /=, %=
5)字符串连接运算符:+
6)三目/条件运算符: boolean?数1:数2

6.分支结构:基于条件的执行

1)if结构:1条路
2)if…else结构:2条路
3)if…else if结构:多条路
4)switch…case结构:多条路
优点:效率高、结构清晰
缺点:整数、相等
break:跳出switch

发表于

Windows GitHub+Hexo 搭建个人网站教程

搭建步骤：

  1. GitHub创建个人仓库
  2. 安装Git
  3. 配置和使用Github
  4. 安装Node.js
  5. 安装Hexo
  6. 推送网站

创建GitHub个人仓库

登录到GitHub,如果没有GitHub帐号，使用你的邮箱注册GitHub帐号注册完成后


我们来New repository创建新仓库，仓库名为：你的用户名.github.io
这个用户名使用你的GitHub帐号名称代替 这是标准写法

安装 Git

简单了解一下Git：git的作用就是对文件进行版本管理，方便在不同版本进行切换修改，类似文件分不同时间备份让后需要时找回其中一份代替，不过更方便使用。
下载并安装：网址 https://git-scm.com/download/win

配置和使用GitHub

在桌面 右键 找到:

生成新的 SSH Key：

1
ssh-keygen -t rsa -C "输入你注册的邮箱"

提示： -C “C”是大写
然后 敲三下回车就可以了

添加SSH Key到GitHub

找到id_rsa.pub文件 如图：

用记事本打开 复制里面的全部数据 之后打开你的GitHub 右上角头像位置如图：

点击第一个 New SSH key

第一行 标题 随便填（最好填上） 然后把你复制的数据粘贴到Key中 之后点Add SSH key
接下来 测试
还在 git bash 里 输入命令 （就是这个命令不要更改 原样打上） 然后输入yes 回车 如图：

1
ssh -T git@github.com

接下来可以通过 SSH 链接到GitHub 了。 输入：

1
2
git config --global user.name "你的GitHub用户名"
git config --global user.email "你的GitHub注册邮箱"

安装 Node.js

Node.js下载地址：Download | Node.js 下载安装包，注意安装Node.js会包含环境变量及npm的安装，安装后，检测Node.js是否安装成功 在命令符中输入 :

1
node -v

检测npm是否安装成功，在命令符中输入 :

1
npm -v

安装 Hexo

在安装hexo之前 保证Git和Node.js 安装好之后 来安装hexo

Hexo就是我们的个人博客网站的框架， 接下来在电脑盘里创建一个文件夹，可以命名为Blog，Hexo框架与以后你自己发布的网页都在这个文件夹中。创建好后，进入文件夹中，按住shift键，右击鼠标点击命令行：

使用命令来安装 Hexo：

1
npm install -g hexo-cli

安装 Hexo 完成后，请执行下列命令，Hexo 将会在指定文件夹中新建所需要的文件。

1
2
3
hexo init <folder> # 就是你创建的文件夹
cd <folder>
npm install

创建一篇文章

1
hexo new 文章名

检测我们的网站雏形 输入：

1
hexo serve

执行完命令后就可以到浏览器输入 localhost:4000 查看到了 (上面也提示了 )

推送网站

上面只是在本地预览，接下来要做的就是就是推送网站，也就是发布网站，让我们的网站可以被更多的人访问。

将我们的Hexo与GitHub关联起来，打开站点的配置文件_config.yml，翻到最后修改为：

1
2
3
4
deploy:
  type： git
  repo： git@github.com:Alone5/alone5.github.io.git
  branch： master

安装Git部署插件,输入命令：

1
npm install hexo-deployer-git --save

然后 分别输入三个命令：

1
2
3
hexo clean 
hexo g 
hexo d

第三条的 hexo d 就是部署网站命令，d是deploy的缩写。完成后，打开浏览器，在地址栏输入你的放置个人网站的仓库路径，即 http://xxxx.github.io 例如我的 ： alone5.github.io

这样你的博客就已经上线了，可以在网络上被访问了。

博客源码使用GitHub维护

  1. 新建仓库 hexo-blog

  2. 将本地的blog文件夹与远程仓库关联

    1
    2
    3
    4
    5
    6
    $ cd hexo-blog
    $ git init
    $ git add .
    $ git commit -m "first commit"
    $ git remote add origin git@github.com:Alone5/hexo-blog.git
    $ git push -u origin master

  3. 每次本地编辑完成之后，上传到github

    1
    2
    3
    $ git add .
    $ git commit -m '注释'
    $ git push origin master

  4. 将github上的文件同步到本地

    1
    $ git pull