Java学习笔记文章目录Java学习笔记1.环境搭建安装JDK设置环境变量2.Java基础语法变量和数据类型基本类型的变量基本数据类型方法与数组**方法的定义：****参数：**方法的返回值方法的重载数组的定义数组的赋值方式数组的遍历数组示例多维数组示例：最大值最小值算法冒泡排序算法选择排序算法直接插入排序算法二分查找算法Arrays类双色球模拟综合案例3.面向对象基本概念类与对象**类与对象的关系****类和对象的定义格式****对象的内存分析****类与对象小结**封装性成员变量和局部变量构造方法构造
Java学习笔记
文章目录
1.环境搭建
安装JDK
因为Java程序必须运行在JVM之上，所以，第一件事情就是安装JDK。
搜索JDK 13，确保从Oracle的官网下载最新的稳定版JDK：
设置环境变量
安装完JDK后，需要设置一个JAVA_HOME的环境变量，它指向JDK的安装目录。在Windows下，它是安装目录，类似：
C:\Program Files\Java\jdk-13
在Mac下，它在~/.bash_profile里，它是：
export JAVA_HOME=`/usr/libexec/java_home -v 13`
然后，把JAVA_HOME的bin目录附加到系统环境变量PATH上。在Windows下，它长这样：
Path=%JAVA_HOME%\bin;<现有的其他路径>
在Mac下，它在~/.bash_profile里，长这样
export PATH=$JAVA_HOME/bin:$PATH
把JAVA_HOME的bin目录添加到PATH中是为了在任意文件夹下都可以运行java。打开命令提示符窗口，输入命令java -version，如果一切正常，你会看到如下输出：
┌────────────────────────────────────────────────────────┐
│Command Prompt - □ x │
├────────────────────────────────────────────────────────┤
│Microsoft Windows [Version 10.0.0] │
│(c) 2015 Microsoft Corporation. All rights reserved. │
│ │
│C:\> java -version │
│java version "13" ... │
│Java(TM) SE Runtime Environment │
│Java HotSpot(TM) 64-Bit Server VM │
│ │
│C:\> │
│ │
│ │
└────────────────────────────────────────────────────────┘
如果你看到的版本号不是13，而是12、1.8之类，说明系统存在多个JDK，且默认JDK不是JDK 13，需要把JDK 13提到PATH前面。
如果你得到一个错误输出：
┌────────────────────────────────────────────────────────┐
│Command Prompt - □ x │
├────────────────────────────────────────────────────────┤
│Microsoft Windows [Version 10.0.0] │
│(c) 2015 Microsoft Corporation. All rights reserved. │
│ │
│C:\> java -version │
│'java' is not recognized as an internal or external comm│
│and, operable program or batch file. │
│ │
│C:\> │
│ │
│ │
│ │
└────────────────────────────────────────────────────────┘
2.Java基础语法
简要介绍下类、对象、方法和实例的概念。
- 对象：对象是类的一个实例，有一个对象，有一个对象，它的有：颜色、名字、方法；行为有：摇尾巴、叫声、吃等。
- 类：类是一个模板，它描述对象的行为和状态。
- 方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作方法都在中完成的。
- 实例变量：每个变量对象存在独特的实例，对象的状态由这些实例变量的值决定。
第一个程序HelloWorld
/**
* 可以用来自动创建文档的注释
*/
public class Hello {
public static void main(String[] args) {
// 向屏幕输出文本:
System.out.println("Hello, world!");
/* 多行注释开始
注释内容
注释结束 */
}
} // class定义结束
变量和数据类型
按所属的数据类型划分：基本类型的变量和引用类型的变量。
按被声明的位置划分：局部变量（方法或语句块内部定义的变量）和成员变量（方法外部、类的内部定义的变量）
基本类型的变量
在Java中，变量必须先定义后使用，在定义变量的时候，可以给它一个初始值。例如：
int x = 1;
基本数据类型
基本数据类型是CPU可以直接进行运算的类型。Java定义了以下几种基本数据类型：
- 整数类型：byte，short，int，long
- 浮点数类型：float，double
- 字符类型：char
- 布尔类型：boolean
基本数据类型转换：
- 容量小的类型自动转换成容量大的类型
- byte,short,int,它们三者再计算时会转换成int类型
- 如果把int值转换成float值，或者long转换成double值，不需要强制转换，但可能丢失精度
强制类型转换：
- 容量大的类型转换成容量小的数据类型时，要加上强制转换符
方法与数组
方法的定义：
方法（又叫函数）就是一段特定功能的代码块。方法提高程序的复用性和可读性。
方法的格式
// 语法：
// 访问权限修饰符[其他的修饰符如static]返回值类型 方法名（参数类型1形参1，参数类型2形参2，...）{// 形参列表
// 方法体
return 返回值；
}
参数：
实际参数：就是实际参与运算的。
形式参数：就是方法定义上的，用于接受实际参数的；
参数类型：就是参数的数据类型
参数名：就是变量名
方法体语句：就是完成功能的代码
注意：
1.若当前方法中不要使用形参，那么形参列表可以为空
2.实参和形参的类型要相互兼容，且：实参的取值范围要小于或者等于形参类型的取值范围
在调用方法中，如果我们定义的方法有参数，就必须在调用方法的同时传入这个值，即给当前方法中的参数赋值，而这个传入的值我们称为实记参数，也就是实参
实参：传入的参数值
形参：接受实参传过来的值
注意：实参名与形参名可以相同，也可以不同
小结：形参就是一个变量，实参就是一个值，传参就是把一个值给一个形参赋值
方法的返回值
return: 结束方法的
返回值：就是功恩的结果，由return带给调用者。
注意：
- 若当前方法没有返回值类型，即返回值类型是void，那么当前方法中可以不写return
- return即表示结束一个方法，也可以将返回值返回给调用当前方法的调用者
- return返回值时一次只能返回一个值，不可以返回多个值
- 一个方法中可以有多个return，但被执行的只能有一个，所以需要判断
练习：
-
判断任意给定年份是否是闰年
public class test { public static void main(String[] args){ boolean bool = isRunNian(2017); if(bool){ System.out.println("是闰年"); }else{ System.out.println("是平年"); } } public static boolean isRunNian(int year){ if((year%4==0 && year%100!=0) || year%400==0){ return true; }else{ return false; } } } -
根据传入的参数数量打印直角三角形
public class printTriangle { public static void main (String[] args){ Scanner input = new Scanner(System.in); int num = input.nextInt(); print(num); } public static void print(int line) { for(int i=1 ; i<=line ; i++) { // 控制行数 for(int j=i;j<line;j++) { System.out.print(" "); } for(int k=1; k<=i*2-1; k++) { System.out.print("*"); } System.out.println(); } } }
方法的重载
方法重载：overloading method
在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义；
返回值不能作为重载的条件
// 如：
public void method(int a){...}
public void method(char b){...}
数组的定义
数组：一组能够存储相同数据类型值的变量的集合
当我们有个一组相同类型的数据需要存储，如果次是使用单个变量的来存储，我们将要定义若干个变量名，这样将会非常繁琐，并不利于维护
数组的赋值方式
四种：
-
使用默认的初始值来初始化数组中的每一个数组
语法：数组元素类型 [] 数组名 = new 数组元素类型[数组中元素的个数（数组的长度）]
如：int [] scores = new int[3];
-
先声明，然后再赋予默认的初始值
语法：数组元素类型 [] 数组名；
数组名 = new 数组元素类型[数组中元素的个数（数组的长度）]；
如：int [] scores;
scores = new int[3]；
-
先声明，然后在使用特定的值进行初始化
语法：数组元素类型 [] 数组名 = new 数组元素类型 [] {元素1，元素2，…}；
如：int [] scores = new int[]{56，78，98}；
-
将第三种写法可以简化为（使用数组常量值给数组进行赋值）
语法：数组袁术类型 [] 数组名 = {元素1，元素2，…}；
如：int [] scores = {56，78，98}
数组的遍历
遍历：依次语出数组中的每一个元素
通过下标来访问数组的元素
下标： 从0开始，到数组长度-1
-
遍历方法一：普通的for循环
语法：for(int i = 0; i< 数组的长度; i++){
// i: 循环变量，同样：也是数组的下标（取值范围[0,数组的长度]）
数组中元素的类型 变量 = 数组名[i]；
}
-
遍历方式二：使用增强for循环【foreach循环】
语法：for(数组中元素的类型 变量：数组名){
数组中元素的类型 临时变量 = 变量；
}
数组示例
-
猜数游戏，从键盘中任意输入一个数据，判断数列中是否包含此数
public class test2 { // 猜数游戏，从键盘中任意输入一个数据，判断数列中是否包含此数 public static void main(String[] args) { int[] nums = {2,32,23,54,60}; Scanner input = new Scanner(System.in); System.out.println("请输入你要猜的数：（60以内）"); int userNum = input.nextInt(); boolean flag = false; for(int i:nums){ if(userNum == i){ flag = true; break; } } if(flag) { System.out.println("恭喜你猜对了"); }else{ System.out.println("猜错了继续努力"); } } } -
打印正三角形
多维数组示例：
1.一起来参加屌丝程序员大赛把，有3个班级各3名学员参赛，记录每个学员的成绩，并计算每个班的平均分。
public class test3 {
public static void main(String[] args){
int [][] scores = {
{99,78,50},{90,86},{67,87,56}};
int classLen = scores.length;
for(int[] i:scores){
int sum = 0;
for(int j:i){
sum += j;
}
int avg = sum / i.length;
System.out.println("平均成绩:"+avg);
}
}
}
最大值最小值算法
求最大值与最小值的算法
最大值：在一个数列中找出最大的数
public class test4 {
public static void main(String[] args){
int[] nums = {1,2,3,4,5,6};
int max = max(nums);
System.out.println(max);
}
public static int max(int [] nums){
int max = nums[0];
int len = nums.length;
for(int i = 1;i<len;i++){
if(max < nums[i]){
nums[i] = nums[i] + max;
max = nums[i] - max;
nums[i] = nums[i] - max;
}
}
return max;
}
}
最小值：在一个数列中找出最小的数
public class test4 {
public static void main(String[] args){
int[] nums = {1,2,3,4,5,6};
int min = min(nums);
System.out.println(min);
}
public static int max(int [] nums){
int min = nums[0];
int len = nums.length;
for(int i = 1;i<len;i++){
if(min > nums[i]){
nums[i] = nums[i] + min;
min = nums[i] - max;
nums[i] = nums[i] - min;
}
}
return min;
}
}
冒泡排序算法
冒泡排序算法
冒泡排序算法的运作如下：（从后往前）
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，知道没有任何一对数字需要比较。
相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法
public class test5 {
public static void main(String[] args){
int[] nums = {10,21,3,34,5,19};
int len = nums.length-1;
for(int i = 0; i < len;i++){
for(int j = 0; j < len-i;j++){
if(nums[j] > nums[j+1]){
nums[j+1] = nums[j]+nums[j+1];
nums[j] = nums[j+1] - nums[j];
nums[j+1] = nums[j+1] - nums[j];
}
}
}
for(int n:nums){
System.out.println(n);
}
}
}
选择排序算法
每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法
public class test6 {
public static void main(String[] args){
int[] nums = {10,21,3,34,5,19};
int len = nums.length;
int minIndex;
for(int i=0;i<len;i++){
minIndex = i;
for(int j=i+1;j<len-1;j++){
if(nums[minIndex] > nums[j]){
minIndex = j;
}
}
if(minIndex != i){
if(nums[i] > nums[minIndex]){
nums[minIndex] = nums[i]+nums[minIndex];
nums[i] = nums[minIndex] - nums[i];
nums[minIndex] = nums[minIndex] - nums[i];
}
}
}
for(int n:nums){
System.out.println(n);
}
}
}
直接插入排序算法
直接插入排序算法
（从后向前找到合适位置后插入）
**基本思想：**每步将一个待排序的记录，按其顺序码大小插入到前面已经排好序的子序列的合适位置（从后向前找到合适位置后），直到全部插入排序完为止。
public class test7 {
public static void main(String[] args){
int[] nums = {10,21,3,34,5,19};
for(int i = 1;i<nums.length;i++){
int temp = nums[i];
int j;
for(j = i-1;j>=0;j--){
if(nums[j] > temp){
nums[j+1] = nums[j];
}else{
break;
}
}
if(temp != nums[j+1]){
nums[j+1] = temp;
}
}
for(int n:nums){
System.out.println(n);
}
}
}
二分查找算法
二分法查找（折半查找）：前提是在已经排好序的数组中，通过将待查找的元素与中间索引值对应的元素进行比较，若大于中间索引值对应的元素，去右半部分查找，否则，去左半部分查找。依次类推。知道找到为止，找不到返回一个负数。
public class test8 {
public static void main(String[] args){
int[] nums = {1,2,3,4,5,6};
int index = binarySearch(nums,3);
System.out.println(index);
}
public static int binarySearch(int[] nums, int key){
int start = 0;
int end = nums.length-1;
while (start<=end){
int middle = (start+end)/2;
if(nums[middle]>key){
end = middle-1;
}else if(nums[middle]<key){
start = middle+1;
}else{
return middle;
}
}
return -1;
}
}
Arrays类
Arrays工具类：用来操作数组（比如排序和搜索）的各种方法
常用方法：
-
使用二分法查找
Arrays.binarySearch(int [] array,int value);
-
数组内容转成字符串的形式输出
Arrays.toString(int [] array);
-
数组排序
Arrays.sort(int[] array);
-
复制指定的数组
Arrays.copyOf(int[] array,int length)
Arrays.copyOf(int[] array,int form,int to)
System.arraycopy(Object src, int s rcPos,Object dest,int destPos,int length)
-
判断两个数组是否相等
Arrays.equels();
-
使用指定元素填充数组
Arrays.fill()
双色球模拟综合案例
一、双色球彩票玩法
玩法说明：
双色求投注区分为红色号码区和蓝球号码区，红球号码范围为0133，蓝球号码范围为0116。双色球每期从33个红球中开出6个号码，从16个蓝球中 开出1个号码作为中将号码，双色球玩法即是竞猜开奖号码的6个红球号码和1个蓝球号码，顺序不限
二、案例分析
1、如何产生蓝球和红球？
2、如何接受用户选号？
3、如何验证是否中奖？
4、公布本期中将号码？
三、实现步骤：
1、整体实现思路
2、随机取值不重复算法（系统和用户）
3、判断是否中奖的逻辑
4、结果输出
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
public class test9 {
public static void main(String[] args){
// 定义相关变量
int[] userRedBall = new int[6];// 用户选择的红球号码
int[] sysRedBall = new int[6];// 系统生成的红球号码
int userBlueBall = 0;// 用户选择的蓝球号码
int sysBlueBall = 0;// 系统生成的蓝球号码
int redCount = 0;// 记录用户选择正确的红球
int blueCount = 0;// 记录用户选择正确的蓝球
int [] redBall = new int[33]; //用于存储1-33的红球号码
for(int i = 0;i<redBall.length;i++){
redBall[i] = i+1;
}
// 游戏开始提示
System.out.println("双色球游戏开始，good luck");
System.out.println("请问你是要机选还是要手选：（1：机选，2：首选）");
Scanner input = new Scanner(System.in);
Random r = new Random();
boolean flag = true;
while(flag){
int isAuto = input.nextInt();
switch (isAuto){
case 1:
// 机选
computerSelect(redBall,userRedBall);
userBlueBall = r.nextInt(16)+1;
flag = false;
break;
case 2:
// 手选
System.out.println("请选择6个红球号码（1-33）");
for(int i=0;i<userRedBall.length;i++){
userRedBall[i] = input.nextInt();
}
System.out.println("请选择1个蓝球号码（1-16）");
userBlueBall = input.nextInt();
flag = false;
break;
default:
System.out.println("请问你是要机选还是要手选：（1：机选，2：首选）");
break;
}
}
// 系统随机生成号码
computerSelect(redBall,sysRedBall);
sysBlueBall = r.nextInt(16)+1;
for(int i=0;i<userRedBall.length;i++){
for(int j=0;j<sysRedBall.length-redCount;j++){
if(userRedBall[i] == sysRedBall[j]){
int temp = userRedBall[i];
userRedBall[i] = sysRedBall[userRedBall.length-1-redCount];
sysRedBall[userRedBall.length-1-redCount] = temp;
redCount++;
break;
}
}
}
if(userBlueBall == sysBlueBall){
blueCount = 1;
}
if(blueCount==0 && redCount<=3){
System.out.println("没中奖");
}else if(blueCount==1 && redCount<3){
System.out.println("中了六等级，5块钱");
}else if(blueCount==1 && redCount==3 || blueCount==0 && redCount==4){
System.out.println("中了五等级，10块钱");
}else if(blueCount==1 && redCount==4 || blueCount==0 && redCount==5){
System.out.println("中了四等级，200块钱");
}else if(blueCount==1 && redCount==5){
System.out.println("中了三等级，3000块钱");
}else if(blueCount==0 && redCount==6){
System.out.println("中了三等级，150w块钱");
}else if(blueCount==1 && redCount==6){
System.out.println("中了三等级，500w块钱");
}else{
System.out.println("系统有误，中奖无效");
}
// 系统号码
System.out.println("本期中奖的红球");
Arrays.sort(sysRedBall);
System.out.println(Arrays.toString(sysRedBall));
System.out.println("本期中奖的蓝球");
System.out.println(sysBlueBall);
// 用户号码
System.out.println("你选择的红球");
Arrays.sort(userRedBall);
System.out.println(Arrays.toString(userRedBall));
System.out.println("你选择的蓝球");
System.out.println(userBlueBall);
}
public static void computerSelect(int[] redBall,int[] userRedBall){
Random r = new Random();
int index = -1;
for(int i=0;i<userRedBall.length;i++){
index = r.nextInt(redBall.length-i);
userRedBall[i] = redBall[index];
//交换位置
int temp = redBall[index];
redBall[index] = redBall[redBall.length-1-i];
redBall[redBall.length-1-i] = temp;
}
}
}
3.面向对象基本概念
一、什么是面向对象：
1.面向对象是一种编程思想。
2.面向对象是一种思考问题的思维方式。
二、简历面向对象思维方式：
1.先整体，再局部
2.先抽象，再具体
3.能做什么，再怎么作
三、如何学习面向对象
1.掌握一门面向对象语言的语法
2.熟悉面向对象的设计原则
3.熟悉面向对象设计模式
类与对象
- 类是：分类、类别
- 通过分类，我们可以区别不同的事物种类，在日常生活当中，我们唱常这么做。
- 所以，类是一组具有相同特性（属性）与行为（方法）的事物集合。
类与对象的关系
-
类便是一个共性的产物，是一个综合的特征，而对象，是一个个性的产物，是一个个体的特征。
-
类由属性和方法组成
属性：就相当于一个个的特征
方法：就相当于人的一个个的行为，例如：说话，吃饭，唱歌，睡觉
类和对象的定义格式
在Java中可以使用一下的语句定义一个类：
class 类名称{
属性名称；
返回值类型 方法名称（）{}
}
对象的定义：
一个类要想真正的进行操作，则必须依靠对象，对象的定义格式如下：
类名称 对象名称 = new 类名称();
按照以上的格式就可以产生对象了。
如果要想访问类中的属性或方法（方法的定义）
则可以依靠一下的语法形式：
访问类中的属性：
对象.属性；
调用类中的方法：
对象.方法()；
对象的内存分析
- new 关键字表示创建一个对象
- new 关键字表示实例化对象
- new 关键字表示申请内存空间
注意：如果一个没有申请内存空间的对象，会报空指针异常
类与对象小结
- new 关键字：表示向内存申请空间，也表示实例化一个对象，创建一个对象。
- 一个对象在内存中的大小，由该对象的所有属性所占的内存大小的总和。引用类型变量在32位系统上占4个字节，在64位系统上占8个字节。加上而歪的对象隐性数据所占的大小。
- 相同的类型才可以赋值
- 不同的引用，指向同一个对象，任何一个引用改变对象的值，其他引用都会反映出来。
- 编程时要注意的问题，在确定不使用对象时，要尽早释放对象：引用=null
- 当一个推中的对象没有被任何引用变量所指向时，该对象会被JVM的GC程序认为是垃圾对象，从而被回收
封装性
一、封装性的概念
-
封装性是面向对象思想的三大特征之一。
-
封装就是隐藏实现细节，仅对外提供访问接口。
封装有：属性的封装、方法的封装、类的封装、组件的封装、模块化的封装、系统级封装…
二、封装的好处
-
模块化
-
信息隐藏
-
代码复用
-
插件化易于调试
-
具有安全性
封装的缺点：会影响执行效率
private关键字：访问权限修饰符，public表示共有的，privat
最低0.47元/天 解锁文章
992
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
