文章目录
简单概述
本篇文章内容为转载学习内容，主要记录自己学习《【多易教育】涛哥java基础十小时玩转编程思想–实现人脸识别不是梦》课程的相关代码与笔记。
软件开发基本概念
什么是软件？
核心要素：
-
提供一个与人交互的界面（桌面程序图形界面、Web界面）
-
可以接收用户输入的数据(比如QQ号、密码、点击动作)
-
可以根据事先安排好的逻辑，结合用户输入的数据 ，执行特定的行为 (验证qq号和密码的正确性)
-
可以展现执行的结果
什么是软件开发——编程
所谓软件开发，就是“制造软件”
数据 + 特定的逻辑
数据：
QQ号 -> 一串字符，通常称为字符串
密码 -> 一串字符
邮箱地址 -> 字符串
昵称 -> 字符串
年龄 -> 整数
逻辑：
如果你点击什么按钮，程序就执行什么逻辑 —— 条件控制
先做什么，再做什么，再做什么 —— 顺序执行
当满足某个条件时，循环反复做类似的事 —— 循环控制
Java语言简介、开发环境安装
Java语言编写的程序不是直接在操作系统之上运行的，它与操作系统之间还有一个中间层，Java虚拟机：JVM
Java语言是一种跨平台的语言
安装java的运行环境+java软件开发工具包
安装一个jdk：java development kits
- 解压安装包到指定目录 - 最好不要放在中文目录或者目录下带有空格
- 配置操作系统的环境变量
验证环境是否配置成功：
按快捷键: win+r
第一个Java程序Hello World上手实践
程序写在哪?
Java程序写在一个普通的文本文件中即可
java程序开发的基本规范
-
代码文件需要以.java作为后缀名
-
代码都需要封装在"类"结构体中(类结构体是Java中的一个基本语法)
-
代码文件名需要跟文件中的类名一致
-
如果需要直接运行这个类，则在类中还需要一个方法结构体，main方法
java程序开发好后，如何运行
-
需要用jdk中的命令行工具javac将java代码文件xx.java编译成xx.class文件
-
然后用jdk中的命令行工具java来运行xx.class中的"类"
Java数据与变量定义
什么是数据？
广义上来说，就是各种类型的信息，比如，描述一个人：
一段文字：
姓名：铁蛋儿，anglebaby
一个数字：
年龄：18 - 数
身高：180.5
布尔类型：
婚否：是，否
由于一个数据在程序中可能会反复使用，在运算中直接"写"数据不太合适，更明智的做法是，用一个变量(代号)来表示这个数据。
变量定义的语法：在定义一个全新的变量时，需要指定这个变量所代表的数据的类型
语法示范：
定义一个变量，用来代表一个人的薪水2000
基础知识：int java语法中的一个关键字，代表一种数据类型，整数
变量定义: 数据类型 变量名
具体示范：int ZhangSanSalary;
变量赋值：变量名 = 数据值
具体示范：ZhangSanSalary = 2000;
以上语句执行后，程序中就有了一个变量，变量名为zhangSanSalary，变量代表的数据类型(变量类型)为int，并且zhangSanSalary这个变量赋予了一个值:2000
Java中的基本数据类型：
表示文字：
字符类型——char 用于表示一个英文字符，比如‘a’这个数据在java中就是一个char类型的数据
表示数：
整数：单字节整数 byte、双字节整数 short、四字节整数 int、八字节整数 long
区别在于能表示的数的范围不同，依次增大
带小数的类型：浮点数 float、双精度数 double (用64为二进制来表示)
区别在于能表示数的范围不同，依次增大
表示布尔：布尔类型 boolean，用于表示两种对立的状态：true | false
Java中的复合数据类型（引用类型）：
字符串: 可以表示一串char数据 (String)
表示一个人的所有数据：
Java中允许程序员利用Java的面向对象的语法来定义自己的复杂的数据类型，比如描述一个人的信息，可以自定义一个数据类型：Person
数据的运算:
数据运算，在java的语法中，是通过表达式来实现的。
数(byte/short/int/long/float/double)类型的运算:
int a = 3;
int b = 10;
计算两数之和：a + b
System.out.println(a+b);
int sum = a + b;
计算两数之差：a - b
int diff = a - b;
计算两数之积: a * b
int multi = a * b;
计算两数之商: a / b
float div = (float)a / (float)b; // 由于整数除法运算会丢失精度，所以先转换成float类型进行运算
计算两数之模(模除):
int mo = a % b;
布尔数据的运算：
boolean a = true;
boolean b = false;
布尔运算：
boolean c1 = a & b; // false
boolean c2 = a && b: // false
boolean d1 = a | b; // true
boolean d2 = a || b; // true
逻辑流程控制语句
软件开发的两大核心要素：
数据：数据是什么？数据的类型有哪些？如何用变量代表数据
逻辑：描述一个业务实现的具体步骤、流程
条件控制：
开发一个婚恋系统：百合网、世纪佳缘
女注册用户：
如果男方身高>175cm，可以给我推荐
或者 如果男方是一个公务员，可以给我推荐
或者 如果男方月收入>4w，给我推荐
否则，不要给我推荐
判断候选对象的身高>175，推荐 或者 如果候选对象是一个公务员，推荐…
public class LogicTest {
public static void main(String[] args) {
int boyZhangHeight = 170;
boolean isAssist = true;
int boyZhangSalary = 45000;
if(boyZhangHeight > 175){ // 条件：本质是一个布尔值(true, false),也可以是一个布尔表达式
System.out.println("身高符合推荐条件");
} else if(isAssist){
System.out.println("职业符合推荐条件");
} else if(boyZhangSalary > 40000){
System.out.println("薪资符合推荐条件");
} else {
System.out.println("不符合推荐条件");
}
int a = 10;
if(a > 5) {
System.out.println("a 大于 5");
}else {
System.out.println("a 小于 5");
}
int b = 10;
if(b == 10) {
System.out.println("b正好等于10");
}
}
}
循环控制：
从今天开始 -> 生命的尽头: 给亲爱的洗衣，做饭
顺序逻辑：
做第一件事情
做第二件事情
逻辑控制——Java语法实现
if-else 条件控制语法:
if(条件1){ // 条件：本质是一个布尔值(true, false),也可以是一个布尔表达式
} else if(条件2){
} else if(条件3){
} else {
}
循环控制——Java语法实现
while循环控制语法:
int days = 0;
while(days<10){
System.out.println("为你洗衣做饭");
days = days + 1;
}
// 第一次执行: days->0 判断days是否<10 ->成立
// 执行while大括号中的语句: 往控制台打印一句话 days->1
// 第二次执行: days->1, 再次判断days<10 -> 成立
// 执行while大括号中的语句: 往控制台打印一句话 days->2
// 第三次执行: days->2, 再次判断days<10 -> 成立
// 执行while大括号中的语句：往控制台打印一句话 days->3
// ...
// 第十次执行: days->9, 再次判断days<10 -> 成立
// 执行while大括号中的语句: 往控制台打印一句话 days->10
// 第十一次执行: 第十次执行: days->10, 再次判断days<10 -> 不成立
// 结束执行
for循环控制语法:
for(int i = 0; i < 10; i++){
System.out.println("为你洗衣做饭" + i)
}
逻辑代码封装——方法
某个商城在进行促销活动，会给商品打折扣，折扣的逻辑：
- 如果用户购买商品原价总额在<100元，成交价->原价总额*0.9
- 如果用户购买商品的原价总额在>=100元，成交价->原价总额*0.8
- 如果用户购买商品的原价总额在>=200元，成交价->原价总额*0.7
客户A买了商品，计算一次折扣价
客户B买了商品，计算一次折扣价
public class MethodTest {
public static void main(String[] args) {
float aAmount = 75.0f;
float discount;
if(aAmount < 100){
discount = aAmount * 0.9f;
} else if (aAmount >= 100 && aAmount < 200) {
discount = aAmount * 0.8f;
} else {
discount = aAmount * 0.7f;
}
System.out.println("A用户:" + discount);
float bAmount = 275.0f;
if(bAmount < 100){
discount = bAmount * 0.9f;
} else if (bAmount >= 100 && bAmount < 200) {
discount = bAmount * 0.8f;
} else {
discount = bAmount * 0.7f;
}
System.out.println("B用户:" + discount);
}
}
方法: 就是用于封装一段需要反复重用的逻辑代码的结构体
public static 返回数据的类型 方法名(参数变量定义, 参数变量定义){
// 逻辑代码
return 结果;
}
方法操作
public class MethodTest {
public static void main(String[] args) {
float aAmount = 75.0f;
float bAmount = 275.0f;
float cAmount = 188.8f;
double aDiscount = getDiscount(aAmount);
double bDiscount = getDiscount(bAmount);
double cDiscount = getDiscount(cAmount);
System.out.println("A用户的折扣金额为:"+aDiscount);
System.out.println("B用户的折扣金额为:"+bDiscount);
System.out.println("C用户的折扣金额为:"+cDiscount);
}
// 给我一个原价总金额，我就还给你一个折扣金额
// 方法定义
public static double getDiscount(float originAmount){
double disCount;
if (originAmount < 100) {
disCount = originAmount * 0.9;
} else if(originAmount >= 100 && originAmount < 200) {
disCount = originAmount * 0.8;
} else {
disCount = originAmount * 0.7;
}
return disCount;
}
}
数据+逻辑代码封装——类和对象
类用于封装数据
描述订单：
订单id：订单的唯一表示 -> 用字符串来描述，string
订单总金额：选购商品的金额总和 -> 用双精度数来描述，double
订单应付金额：总金额基础之上的折扣金额 -> 用双精度数来描述，double
描述订单1：
String order1_id = "od0001";
double order1_amount = 1800;
double order1_payment = order1_amount * 0.95;
描述订单2：
String order2_id = "od0001";
double order2_amount = 1800;
double order2_payment = order1_amount * 0.95;
描述订单3:
String order2_id = "od0001";
double order2_amount = 1800;
double order2_payment = order1_amount * 0.95;
Java中设计了一个机制，用来描述复杂事物的数据，类 -> 对象
类: 定义复杂事务有哪些数据项的一个模板
对象：就是符合类模板的具体的一套数据
类的语法
- 类是由开发者自己来创建，自己根据所要描述数据的需求来创建；
- 一个类其实就是一个语法结构:
class Order{
}
- 一个类最好创建在一个.java文件中，而且文件名最好跟类名一致
public class Order {
String order_id;
double order_amount;
double order_payment;
}
根据类创建对象
类只是描述事物的一个模板；
对象才是描述具体事物的数据包；
创建对象的基本语法:
Order order1 = new Order(); // 创建出一个订单对象
// 为新创建出来的订单对象中的数据项(成员变量)赋值
order1.order_amount = 1800.0;
order1.order_payment = 1800 * 0.95;
order1.order_id = "002"
上述语句：初学阶段，建议写在方法中:
类用于封装逻辑(方法)
类中可以定义方法，方法中的逻辑通常用于操作具体对象上的数据
public class Order {
String order_id;
double order_amount;
// 将这个成员变量修饰成私有
private double order_payment;
// 计算应付金额的方法
public void setOrder_payment(){
// this就代表将来执行方法时指定的对象
this.order_payment = this.order_amount * 0.95;
}
public String getOrder_id(){
return this.order_id;
}
// static方法称为静态方法，可以直接在类上调用
// 这个方法不应该与任何具体对象上的数据相关
public static void sayHello(){
System.out.println("hello, 我是一个订单");
}
}
-
类中可以定义方法
-
类中定义的非静态方法需要在具体的对象上调用
-
类中定义的静态方法，可以直接在类上调用(可以通过 类名.静态方法名() 来调用方法中的逻辑语句)
public class Order {
String order_id;
double order_amount;
// 将这个成员变量修饰成私有的
private double order_payment;
// 构造方法: 用于在构造对象时，快速给对象的成员变量赋值
public Order(String id, double amount){
this.order_id = id;
this.order_amount = amount;
this.order_payment = this.caclPayment();
}
// 计算应付金额的方法
public void setOrder_payment(){
double payment = this.caclPayment();
// this就代表将来执行方法时指定的对象
this.order_payment = payment;
}
private double caclPayment() { // 将这个成员方法修饰成私有的
return this.order_amount * 0.95;
}
public String getOrder_id(){
return this.order_id;
}
// static方法称为静态方法，可以直接在类上调用
// 这个方法不应该与任何具体对象上的数据相关
public static void sayHello(){
System.out.println("hello, 我是一个订单");
}
public double getPayment(){
return this.order_payment;
}
}
用于调用的处理文件:
public class OrderTest {
public static void main(String[] args) {
Order.sayHello(); // 在类上直接调用定义好的静态方法
Order order1 = new Order("001", 1800.00);
// order1.order_id = "001";
// order1.order_amount = 1800.00;
// order1.setOrder_payment();
// // 私有成员不允许在Order类以外的地方赋值
// order1.order_payment = order1.order_amount * 0.95;
// System.out.println(order1.order_payment);
System.out.println(order1.getPayment());
System.out.println(order1.getOrder_id());
Order order2 = new Order("002", 2800.00);
// order2.order_id = "002";
// order2.order_amount = 2800.00;
// order2.setOrder_payment(); // 非静态方法必须在对象上调用
// System.out.println(order2.order_payment);
System.out.println(order1.getPayment());
System.out.println(order2.getOrder_id());
}
}
组件式开发——不用重复造轮子
类：一个用于描述某类事物所具备的数据项的模板，还可以定义操作数据的方法
对象：是类的一个具体实例(一套具体的数据)
方法：在对象上调用方法时，就可以通过方法中的逻辑来操作对象中的数据
构建大型系统时，不需要从最基础的代码开始开发
jdk中，以及很多第三方(个人、公司、机构)，开发了大量的具备一定功能的类，那么我们在构建大型系统时，就可以直接基于这些现成的类来构建。
从此，开发软件，就像汽车厂商，不用从铁矿石的提炼开始了，而是收集大量的零部件进行组装即可。
比如，需要在程序中操作一大段的字符
char c1 = 'H';
char c2 = 'e';
char c3 = 'l';
char c4 = 'l';
char c5 = 'o';
// string jdk中一个现成的类，它可以封装一串字符，并且拥有大量的操作这一串字符数据的功能方法。
String str = new String("hello world");
String[] words = str.split("");
容器类组件——数组
需求：
班主任老师，让王同学，统计一下全班同学的总分，平均分，最高分，最低分
float a = 90;
float b = 80;
// 存储一组相同类型的数据：jdk中有现成的组件——数组
float[] score = new float[10];
// 往数组中存储数据
score[0] = 98;
score[1] = 95;
score[2] = 60;
float[] score2 = new float[]{98, 95, 60, 80, 99, 100, 45, 59};
float[] score3 = {98, 95, 60, 80, 99, 100, 45, 59};
// 取数组中的元素
System.out.println(score[0]);
// 修改数组中的元素
score[0] = 69;
System.out.println(score[0]);
// 求总分
float sum = 0;
for(int i = 0; i < score2.length; i++){
sum = sum + score2[i];
}
System.out.println("总分为:" + sum);
// 求平均分
float average = sum / score2.length;
System.out.println("平均分为:" + average);
字符串类常见功能
public class StringDemo {
public static void main(String[] args){
// 创建一个字符串数据
String str1 = "Order01, Pdt001, User001, 18.8";
String str2 = new String("order01, pdt001, user001, 18.8");
// 字符串的切割 "order001" "pdt001" "user001" "18.8"
String[] fields = str1.split(",");
for(int i = 0; i < fields.length; i++) {
System.out.println(fields[i]);
}
// 求字符串的长度
System.out.println(str1.length());
// 判断两个字符串的内容是否相等
boolean equal = str1.equals(str2);
System.out.println(equal);
System.out.println(str1.equals("abc"));
// 将字符串转成大小写
String upper = str1.toUpperCase();
// 并不是把str1变成了大写，而是生成一个新的字符串：内容是
// str1中的内容大写之后的结果
System.out.println(upper);
String lower = str1.toLowerCase();
// 并不是把str1变成了小写，而是生成一个新的字符串：内容是
// str1中的内容小写之后的结果
System.out.println(lower);
// 截取字符串的子串
String sub = str1.substring(0, 8);
System.out.println(sub);
// 判断一个字符串是否以指定的前缀开始
boolean start = str1.startsWith("Or");
System.out.println(start);
// 判断一个字符串是否以指定的后缀结束
boolean end = str1.endsWith(".8");
System.out.println(end);
}
}
容器类组件——ArrayList
比如：开发一个购物系统，系统中需要帮客户记录购买的商品信息
import java.util.ArrayList;
public class Shopping {
public static void main(String[] args){
String product1 = "苹果";
String product2 = "香蕉";
String[] cart = new String[3]; // 数组的长度是固定的，无法增长，无法缩短
cart[0] = "苹果";
cart[1] = "香蕉";
cart[2] = "梨子";
// cart[3] = "桔子"; //数组角标越界
// 可以伸缩自如类似数组的容器组件: ArrayList
// 创建一个ArrayList容器对象时，不需要指定长度
ArrayList<String> ShoppingList = new ArrayList<String>();
ShoppingList.add("苹果");
ShoppingList.add("香蕉");
ShoppingList.add("梨子");
ShoppingList.add("桔子");
// 删除List容器对象中的第4个元素: 桔子
ShoppingList.remove(3);
// 修改数据
ShoppingList.set(0, "apple");
// 取数据
String tmp = ShoppingList.get(0);
// System.out.println("精品" + tmp);
for(int i =0; i < ShoppingList.size(); i++){
System.out.println("精品" + ShoppingList.get(i));
}
}
}
容器类组件——HashSet
import java.util.HashSet; // 导包
import java.util.Iterator;
public class HashSetDemo {
public static void main(String[] args){
String[] strArr = {"aa", "a", "b", "aa", "a", "c", "c", "cc", "bb", "cc", "b"};
// 请帮我把上面数组中的字符串去重
/*
* jdk有一个容器组件HashSet，具备一个属性：自动去重
*
* */
HashSet<String> set = new HashSet<String>();
for(int i = 0; i < strArr.length; i++){
set.add(strArr[i]);
}
// 遍历set集合，逐个取元素进行处理
// 迭代器
Iterator<String> itr = set.iterator(); // 利用迭代器遍历set集合
while(itr.hasNext()){
String tmp = itr.next();
System.out.println(tmp);
}
System.out.println("----------这是一个分界线----------");
// jdk还封装了一种语法：增强for循环，来遍历集合
for(String tmp: set){
System.out.println(tmp);
}
// 取set容器的元素个数
int size = set.size();
System.out.println("set中元素的个数为:" + size);
// 判断set中是否包含某个指定的数据
boolean contain = set.contains("aba");
System.out.println("set中包含aa吗？" + contain);
// 清空整个set集合
set.clear();
System.out.println("清空之后的set集合的长度为:" + set.size());
}
}
容器类组件——HashMap
提需求
例如开发一个购物系统，需要记录每个客户挑选的商品和数量
需要一个能够存储一对一数据的容器
key->value 键值对
在jdk中，有现成的容器组件HashMap可以满足上述需求：可以存储key-value对形式的数据
package javase;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
public class HashMapDemo {
public static void main(String[] args){
// 提需求
// 例如开发一个购物系统，需要记录每个客户挑选的商品和数量
// 需要一个能够存储一对一数据的容器
// key->value 键值对
// 在jdk中，有现成的容器组件HashMap可以满足上述需求：可以存储key-value对形式的数据
HashMap<String, Integer> map = new HashMap<String, Integer>();
// 往map容器中存储
map.put("苹果", 5);
map.put("桔子", 3);
map.put("香蕉", 8);
// 数据覆盖
map.put("苹果", 1);
// 从map容器中取数据
Set<Entry<String, Integer>> entryset = map.entrySet();
for (Entry<String, Integer> ent:entryset) {
System.out.println(ent.getKey() + ":" + ent.getValue());
}
// 判断某个指定的key是否包含在map容器中
boolean contain = map.containsKey("火龙果");
System.out.println("购物车中包含火龙果吗？" + contain);
// 取某个指定的key对应的value：比如我想看购物车中桔子买了几个
int number = map.get("桔子");
System.out.println("桔子的个数为:" + number);
// 取map容器的总长度：比如，看看购物车中究竟有几个商品项目
int size = map.size();
System.out.println("购物车中的商品项有:" + size);
}
}
文件读写类组件——File
文件就是某种数据按照特定的编码规则，得到的二进制数据在硬盘中的存储；
package javase;
import java.io.File;
import java.io.IOException;
public class FileDemo {
public static void main(String[] args) throws IOException{
File file = new File("C:/Users/LENOVO/Pictures/Saved Pictures/下载.txt");
// 文件是否存在
boolean exist = file.exists();
System.out.println(exist);
// 指定的文件内容是否是一个文件夹
boolean dir = file.isDirectory();
System.out.println(dir);
// 获取文件名
String name = file.getName();
System.out.println(name);
// 获取文件的绝对路径
String path = file.getPath();
System.out.println(path);
boolean delete = file.delete(); // 删除文件
System.out.println(delete);
// 创建文件
boolean create = file.createNewFile();
System.out.println(create);
File file2 = new File("C:/Users/LENOVO/Pictures/Saved Pictures/test");
System.out.println(file2.isDirectory());
// 列出目录中所有的子节点(文件或子文件夹)
File[] files = file2.listFiles();
for(File f:files){
System.out.println(f.getName());
}
}
}
文件读写组件——IO流
文件就是某种数据(文本、图片、视频、压缩文件)按照特定的编码规则，得到的二进制数据在硬盘中的存储；
字节输入流
FileInputStream 从文件中读取到二进制数据，一般都会将读到的二进制数据转换成具体的信息(文本、图像)
package javase;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class IODemo {
// 一个需求:读取某个文件中的内容
// 读到的是二进制数据,需要通过某种机制转成字符信息
// Java编程就是去利用各种各样的组件实现我们的需求
public static void main(String[] args) throws Exception{
FileInputStream fis = new FileInputStream("C:/Users/LENOVO/Pictures/Saved Pictures/下载.txt");
// int read = fis.read(); // 一次读一个字节，8个二进制比特，在人类数字体系中，表达为一个整数
// System.out.println((char)read);
// read = fis.read();
// System.out.println((char)read);
// int read = 0;
// while((read = fis.read()) != -1){
// System.out.print((char)read);
// }
byte[] b = new byte[1024];
// fis.read(b); // 从文件中一次性读取1024字节的内容，并且放入b这个byte数组
int read = 0;
while ((read = fis.read(b)) != -1){
String str = new String(b, 0, read);
System.out.println(str);
}
}
}
字节输出流
FileOutputStream从代码中将编写的具体的信息存放写入到指定的文件中。
package javase;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class IODemo2 {
public static void main(String[] args) throws Exception{
// 利用线程的工具组件FileOutputStream
FileOutputStream fos = new FileOutputStream("C:/Users/LENOVO/Pictures/Saved Pictures/qingshu.txt");
// 调用fos工具的功能，将我们要写的信息，写入磁盘文件
String str = "hello my name is porter, thanks you";
byte[] buff = str.getBytes();
fos.write(buff);
fos.close();
}
}
版权信息
原文内容来自于课程《【多易教育】涛哥java基础十小时玩转编程思想–实现人脸识别不是梦》，这里本人只负责整理与转载。
本人的Github: PorterZhang2021
114
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
