笔记 9.14

1.Linux:
开源的操作系统，免费，服务器端
目录、挂载点、安全性高
pwd,ls,cd 绝对路径(根) 相对路径(当前目录)
2.java开发环境:
1)编译运行过程:
编译期:.java，经过编译，生成.class字节码文件
运行期:JVM加载.class并运行.class
跨平台，一次编程到处使用
2)JVM:java虚拟机
JRE:java运行环境
JRE=JVM+java系统类库
JDK:java开发工具包
JDK=JRE+编译、运行等工具
3)配置环境变量
3.eclipse:

当前/opt/jdk下，转到/opt/eclipse下:
绝对路径: cd /opt/eclipse
相对路径: cd ../eclipse---------------/opt/eclipse

Linux操作系统:
1.不带图形界面的-----------真正的服务器系统
2.带图形界面的-------------方便操作

公司的电脑--------------Windows系统

Linux系统下运行程序----只需写出它的完整路径即可
/home/soft01/tts9/eclipse/eclipse
假设当前在/home/soft01/tts9/eclipse下
./eclipse

1.变量:存数的，代词，指代的就是它所存的那个数
1)声明:
int a; //声明一个整型的变量，名为a
int b,c,d; //声明三个整型变量，名为b,c,d
2)命名:
2.1)只能包含字母、数字、_和$符，
并且不能以数字开头
2.2)严格区分大小写
2.3)不能使用关键字
2.4)可以中文命名，但不建议
建议"见名知意"、"驼峰命名法"
3)初始化:第一次赋值
3.1)声明的同时初始化
int a = 250; //声明整型变量a并赋值为250
3.2)先声明后初始化
int a; //声明整型变量a
a = 250; //给变量a赋值为250
4)使用:
4.1)变量的使用必须与数据类型匹配
int a = 5.678; //编译错误，类型不匹配
4.2)对变量的使用就是对它所存的那个数的使用
int a=5,b=6;
int c=a+b; //取出a的值5，加上b的值6，再赋值给变量c
System.out.println(c); //输出变量c的值11
System.out.println("c"); //输出c，双引号中的原样输出
a = a+10; //取出a的值5，加10后，再赋值给a
//在a本身基础之上增10
System.out.println(a); //输出变量a的值15
4.3)变量在用之前必须声明并初始化
System.out.println(m); //编译错误，m未声明
int m;
System.out.println(m); //编译错误，m未初始化
2.基本数据类型:
1)int:整型，4个字节，-21个多亿到21个多亿
1.1)整数直接量默认为int型，不能超出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型变量参与运算时，有可能会出现舍入误差
4)boolean:布尔型，1个字节
4.1)只能存储true和false
5)char:字符型，2个字节
5.1)采用Unicode编码，每个字符(char)对应一个码(int)
码的取值范围为0到65535
表现形式是字符char，实质上是码int
5.2)字符需放在单引号中，有且仅有一个
5.3)特殊符号需通过\来转义

3.基本数据类型的转换:
类型从小到大依次为:
byte,short,int,long,float,double
char
1)两种方式:
1.1)自动类型转换:从小类型到大类型
1.2)强制类型转换:从大类型到小类型
有可能发生溢出或精度丢失
2)两点规则:
2.1)整数直接量可以直接赋值给byte,short,char，
但是不能超范围
2.2)byte,short,char型变量参与运算时，
先一律转为int再运算
4.Scanner的用法:
1)在package下:
import java.util.Scanner;
2)在main()方法中:
Scanner scan = new Scanner(System.in);
3)在第2步之下:
System.out.println("请输入年龄:");
int age = scan.nextInt();
System.out.println("请输入价格:");
double price = scan.nextDouble();

1.运算符:
1)算术:+-*/%,++,--
2)关系:>,<,>=,<=,==,!= boolean
3)逻辑:&&(并且),||(或者),!(取反) boolean
4)赋值:=,+=,-=,*=,/=,%=
5)字符串连接:+
6)三目: boolean?数1:数2
2.分支结构:
1)if结构:1条路
2)if...else结构:2条路
3)if...else if结构:多条路
4)switch...case结构:多条路
优点:效率高、结构清晰
缺点:整数、相等
break:跳出switch

1.循环:反复执行一段相同或相似的代码
2.循环三要素:
1)循环变量的初始化
2)循环的条件(以循环变量为基础)
3)循环变量的改变(向着循环的结束变)
循环变量:在循环过程中所改变的那个量
3.循环结构:
1)while:先判断后执行，有可能一次都不执行
2)do...while:先执行后判断，至少会执行一次
第1要素与第3要素相同时首选
3)for:应用率最高，固定次数循环
4.break:跳出循环
continue:跳过循环体中剩余语句而进入下一次循环

1.三种循环的更佳适用情况:
1)while:"当..."循环
2)do...while:"直到..."循环
第1要素与第3要素相同时首选
3)for:固定次数循环
2.嵌套循环:
1)循环中套循环，一般多行多列时使用，外层控制行，内层控制列
2)执行规则:外层循环走一次，内层循环走所有次
3)建议:嵌套层次越少越好，能一层就不用两层，能两层就不用三层
若循环必须超三层才能解决，说明设计有问题
4)break只能跳出一层循环
3.程序=算法+数据结构
算法:解决问题的流程/步骤(顺序、分支、循环)
数据结构:将数据按照某种特定的结构来保存
数怎么存
设计良好的数据结构会导致好的算法
4.数组:
1)相同数据类型元素的集合
2)数组是一种数据类型(引用类型)
3)数组的定义:
//声明整型数组arr，包含4个元素，每个元素都是int型，默认值为0
int[] arr = new int[4];
4)数组的初始化:
int[] arr = new int[4]; //0,0,0,0
int[] arr = {1,3,5,7}; //1,3,5,7
int[] arr = new int[]{1,3,5,7}; //1,3,5,7
int[] arr;
arr = {1,3,5,7}; //编译错误，此方式必须声明同时初始化
arr = new int[]{1,3,5,7}; //正确
5)数组的访问:
5.1)通过数组名.length来获取数组的长度
int[] arr = new int[3];
System.out.println(arr.length); //3
5.2)通过下标/索引方式来访问数组中的元素
下标从0开始，最大到(数组长度-1)
int[] arr = new int[3];
arr[0] = 100; //给第1个元素赋值为100
arr[1] = 200; //给第2个元素赋值为200
arr[2] = 300; 
arr[3] = 400; //数组下标越界异常ArrayIndexOutOfBoundsException
System.out.println(arr[arr.length-1]); //输出最后一个元素的值
6)数组的遍历:
int[] arr = new int[10];
for(int i=0;i<arr.length;i++){ //给每个元素赋值为100
arr[i] = 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)数组的复制:
System.arraycopy(a,1,a1,0,4);
int[] a1 = Arrays.copyOf(a,6);
a = Arrays.copyOf(a,a.length+1);
arraycopy()更灵活，效率更高
copyOf()可以实现数组的扩容
8)数组的排序:
Arrays.sort(arr); //升序排列
冒泡算法:
1)四个数冒三轮
2)每一轮都是从第1个元素开始冒
每一次都是和它的下一个元素比
3)冒出来了就不带它玩了

int[] arr = {45,7,23,2}; //升序(从小到大)

for(int i=0;i<arr.length-1;i++){ //控制轮
for(int j=0;j<arr.length-1-i;j++){ //控制次
if(arr[j]>arr[j+1]){ //和它下一个元素比
int t = arr[j]; //符合则交换
arr[j] = arr[j+1];
arr[j+1] = t;
}
}
}

arr.length-1-i
i=0 走3次
i=1 走2次
i=2 走1次

 

第一轮:
45和7比，换，7,45,23,2
45和23比，换，7,23,45,2
45和2比，换，7,23,2,45----------45冒出来了
第二轮:
7和23比，不换
23和2比，换，7,2,23,45----------23冒出来了
第三轮:
7和2比，换，2,7,23,45-----------7冒出来了

//声明double型数组dous，包含4个元素
//每个元素都是double型，默认值为0.0
double[] dous = new double[4];

//声明整型数组a，包含8个元素
//每个元素都是int型，默认值为0
int[] a = new int[8]; //0,0,0,0,0,0,0,0

for(int i=1;i<=100;i++){
for(int j=1;j<=200;j++){
for(int k=1;k<=300;k++){
break; //只跳出k的层
}
}
}

i=1
j=1
k走30次
j=2
k走30次
j=3
k走30次
...
j=20

 

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

猜字符小游戏:
1.设计数据结构:数据
1)char[] chs; //随机生成的字符数组
2)char[] input; //用户输入的字符数组
3)int[] result; //对比的结果
4)int score; //总分
int count; //猜错的次数

2.设计程序结构:方法
1)主方法:
public static void main(String[] args){

}
2)生成随机字符数组:
public static char[] generate(){
char[] chs = new char[5];
//...
return chs;
}
3)对比:随机字符数组与用户输入的字符数组
public static int[] check(char[] chs,char[] input){
int[] result = new int[2];
//...
return result;
}

/生成随机字符数组
public static char[] generate(){
char[] chs = new char[5];

char[] letters = {'A','B','C','D','E',...'Z'};
boolean[] flags = new boolean[letters.length];
for(int i=0;i<chs.length;i++){
do{
int index = (int)(Math.random()*26);
}while(flags[index]==true);
chs[i] = letters[index];
flags[index] = true;
}
i=0
index=0 chs[0]='A' flags[0]=true
i=1
index=25 chs[1]='Z' flags[25]=true
i=2
index=0/25/0/25/0/25/0/25/1 chs[2]='B' flags[1]=true
i=3
index=0/1/25/0/1/25

return chs;
}

i=0 index=25 chs[0]='Z'
i=1 index=0 chs[1]='A'
i=2 index=24 chs[2]='Y'
i=3
i=4

位置对是在字符对的基础之上

//对比
public static int[] check(char[] chs,char[] input){
int[] result = new int[2]; //0,0 假设result[0]为位置对，result[1]为字符对

for(int i=0;i<chs.length;i++){
for(int j=0;j<input.length;j++){
if(chs[i]==input[j]){ //字符对
result[1]++; //字符对个数增1
if(i==j){ //位置对
result[0]++; //位置对个数增1
}
break; //input中剩余元素不再对比了
}
}
}

return result;
}

i=0
j=0 chs0和input0
j=1 chs0和input1
j=2 chs0和input2
j=3 chs0和input3
j=4 chs0和input4
i=1
j=0 chs1和input0
j=1 chs1和input1
j=2 chs1和input2
j=3 chs1和input3
j=4 chs1和input4

i=2
j=1/2/3/.../20
...
i=10
j=1/2/3/.../20
开关：
public class adminpractice {

public static void main(String[] args) {
Scanner scan = new Scanner(System.in);

int count = 0;

while(true){
System.out.println("请输入账号");
String name = scan.next();

System.out.println("请输入密码");
String pwd = scan.next();

if("admin".equals(name) && "admin".equals(pwd)){
System.out.println("登陆成功");
break;

}else{
count++;
if(count<3){
System.out.println("请再输入一次");
}else{
System.out.println("请滚吧");
break;
}
}



}

}
}
public class chengji {
public static void main(String[] args) {
int[] scores = {89, -23, 64, 91, 119, 52, 73}; // 定义成绩数组
sortResults(scores); // 调用成绩排序输出方法
}

/*
* 功能:
* 定义方法完成成绩排序并输出前三名的功能
* 方法:
* 1.通过Arrays类提供的方法对成绩数组进行排序来获取到一个由低到高的序列
* 2.定义一个有效成绩个数变量
* 3.然后使用for循环倒序遍历(由高到低)成绩，并通过有效成绩个数来控制输出的成绩
* 4.循环过程中过滤掉无效的成绩，记录有效成绩个数，并输出有效成绩
*/
public static void sortResults(int[] scores) {
Arrays.sort(scores); // 对数组进行升序排序
int scoreNum = 0; // 定义有效成绩个数
System.out.println("考试成绩的前三名为:");
for (int i = scores.length - 1; scoreNum < 3 && i >= 0; i--) { // 倒序遍历数组,并通过有效成绩个数判断前三名
if (scores[i] > 100 || scores[i] < 0) { // 过滤无效成绩
continue;
}
scoreNum++; // 有效成绩个数加1
System.out.println(scores[i]); // 每次循环输出有效成绩
}
}
}

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

注意：不要类里面套类
2.如何创建类?如何创建对象?如何访问类中的成员?
3.引用类型之间画等号:
1)指向同一个对象
2)对其中一个引用的修改，会影响另外一个引用
eg: 房子钥匙
基本类型之间画等号:
1)赋值
2)对其中一个变量的修改，不会影响另外一个变量
eg: 身份证复印件
4.null:空，没有指向任何对象
若引用的值为null，则不能再进行任何操作了
操作则NullPointerException空指针异常

步骤:
1.找对象:一个一个的小格子
2.抽类:格子Cell类
3.设计类中的成员变量和方法:
4.创建对象并测试:

引用
数据类型 引用类型变量 指向 对象
Cell c1 = new Cell();

变量
基本类型变量
int a;

引用类型
数据类型 引用 指向 对象
Student zs = new Student();

1:方法的签名: 方法名+参数列表
2.方法的重载(overload):
1)在同一个类中，方法名相同，参数列表不同
2)编译器在编译时根据签名自动绑定调用不同的方法
3.构造方法(构造器，构建器，构造函数):
1)作用:给成员变量赋初值
2)与类同名，没有返回值类型
3)在创建(new)对象时被自动调用的
4)若自己不写构造方法，则编译器默认提供一个无参构造，
若自己写了，则不再默认提供
5)构造方法可以重载
4.this:指代当前对象，谁调指的就是谁
方法中访问成员变量之前默认有个this.
this的用法:
1)this.成员变量名-----------访问成员变量
2)this.方法名()-------------调用方法
3)this()--------------------调用构造方法
5.引用类型数组:
1)Cell[] cells = new Cell[4];
cells[0] = new Cell(2,5);
cells[1] = new Cell(2,6);
cells[2] = new Cell(2,7);
cells[3] = new Cell(3,6);
2)Cell[] cells = new Cell[]{
new Cell(2,5),
new Cell(2,6),
new Cell(2,7),
new Cell(3,6)
};
3)int[][] arr = new int[3][];
arr[0] = new int[2];
arr[1] = new int[3];
arr[2] = new int[2];
arr[1][0] = 100; //给arr中第2个元素中的第1个元素赋值为100
4)int[][] arr = new int[3][4]; //3行4列
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
arr[i][j] = 100;
}
}

4.引用类型数组:
Cell[] cells = new Cell[4]; //创建格子数组对象
cells[0] = new Cell(2,5);

int[][] arr = new int[3][]; //数组的数组
arr[0] = new int[2];

int[][] arr = new int[3][4]; //特殊的简便写法

//声明int[]型数组arr，包含3个元素
//每个元素都是int[]型，默认值为null
int[][] arr = new int[3][];
arr[0] = new int[2];
arr[1] = new int[3];
arr[2] = new int[2];
//给arr中第2个元素中的第1个元素赋值为100
arr[1][0] = 100;

//声明整型数组arr，包含4个元素
//每个元素都是int型，默认值为0
int[] arr = new int[4];

//声明Cell型数组cells，包含4个元素
//每个元素都是Cell型，默认值为null
Cell[] cells = new Cell[4];

调方法时，有参必须传参，参数类型必须匹配

void println(){
}
void println(String a){
}
void println(int a){
}
void println(double b){
}
void println(char c){
}
void println(boolean d){
}

System.out.println();
System.out.println("HelloWorld");
System.out.println(250);
System.out.println(3.56);
System.out.println('女');
System.out.println(true);

1.内存管理:JVM来管理----------大概了解
1)堆:
1.1)存储new出来的对象(包括成员变量)
1.2)成员变量的生命周期:
创建对象时存在堆中，对象被回收时一并消失
1.3)垃圾回收器(GC)不定时到堆中清理垃圾，
凡是没有任何引用所指向的对象都是垃圾
回收过程是透明的，调用System.gc()建议虚拟机尽快来回收
1.4)内存泄露:不再使用的内存没有被及时的回收
建议:不再使用的对象及时将引用设置为null
2)栈:
2.1)存储的是正在调用中的方法中的所有局部变量
2.2)调用方法中，在栈中为该方法分配一块对应的栈帧，
栈帧中存储的是方法中的局部变量(包括参数)，
方法执行结束后，栈帧被清除，局部变量也随之消失
2.3)局部变量的生命周期:
方法被调用时存在栈中，方法执行结束栈帧被清除时一并消失
3)方法区:
3.1)存储的是字节码文件(包括方法)
3.2)方法只有一份
通过this来区分具体的对象
2.继承:
1)作用:避免代码的重复，有利于代码的复用
2)通过extends来实现继承
3)父类:所有子类所共有的属性和行为
子类:子类所特有的属性和行为
4)子继承父后，子具有:
子+父
5)一个父类可以有多个子类，
一个子类只能有一个父类------单一继承
6)继承具有传递性的
7)java规定:构造子类之前必须先构造父类
在子类构造方法中若不调用父类构造，则默认super()调父类无参构造，
而一旦自己调了，则不再默认提供
super()调父类构造，必须位于子类构造的第一句
3.super:指代当前对象的父类对象
super的用法:
1)super.成员变量名-------访问父类的成员变量
2)super.方法名()---------调用父类的方法
3)super()----------------调用父类的构造方法
4.向上造型:
1)父类型的引用指向子类的对象
2)能点出来什么，看引用的类型

例： 
Boo o1 = new Coo(); //向上造型
Aoo o2 = new Coo(); //向上造型
Aoo o = new Doo(); //向上造型

class Aoo{
}
class Boo extends Aoo{
}
class Coo extends Boo{
}
class Doo extends Coo{
}

例：
父类的构造方法能被子类继承吗?------不能
父类的构造是被子类调用的，而不是被子类继承的

Boo o = new Boo(6); //编译错误

class Aoo{
Aoo(int a){
}
}
class Boo extends Aoo{
Boo(){
super(5);
}
}

1.方法的重写(override):
1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
2)重写方法被调用时，看对象的类型
2.重载与重写的区别:------常见面试题
1)重载(overload):
1.1)发生在一个类中，方法名相同，参数列表不同，方法体不同
1.2)遵循"编译期"绑定，看引用的类型绑定方法
2)重写(override):
2.1)发生在父子类中，方法名相同，参数列表相同，方法体不同
2.2)遵循"运行期"绑定，看对象的类型调用方法

//重载看引用，重写看对象
3.package:
1)作用:避免类名的冲突
2)包名可以有层次结构
3)建议:包名所有字母都小写
4)类的全称: 包名.类名
import:
1)同包中的类可以直接访问
不同包中的类不能直接访问，如下两种方式:
1.1)先import声明类，再直接访问类-----建议
1.2)类的全称---------不建议
4.访问控制修饰符
1)public:公开的，任何类
2)private:私有的，本类
3)protected:受保护的，本类、子类、同包类
4)默认的:什么也不写，本类、同包类
注意:
1)类的访问修饰符:public和默认的
2)类中成员访问修饰符:4个都可以

注意：
数据私有化，行为公开化

class Card{
private String cardId;
private String cardPwd;
private double balance;

public boolean payMoney(double money){ //消费
if(balance>=money){
balance-=money;
return true;
}else{
return false;
}
}

public boolean checkPwd(String pwd){ //检测密码
if(pwd.equals(cardPwd)){
return true;
}else{
return false;
}
}
}

public class OverrideOverloadDemo1 {
public static void main(String[] args) {
//重载看引用，重写看对象
Eoo eoo = new Eoo();
Coo o = new Doo(); //向上造型
eoo.test(o);
}
}
/*
* 1.创建Coo类，包含show方法，输出父类show
* 2.创建Doo类，继承Coo，重写show方法，输出子类show
* 3.创建Eoo类，包含:
* 1)test方法，参数为Coo类型的o，方法中:
* 输出父型参数，o.show()
* 2)test方法，参数为Doo类型的o，方法中:
* 输出子型参数，o.show()
* 4.main()方法中:
* 1)创建Eoo对象eoo
* 2)声明Coo型引用o指向Doo的对象
* 3)eoo.test(o);
*/
Eoo eoo = new Eoo();
Coo o = new Doo(); //向上造型
eoo.test(o);

class Eoo{
void test(Coo o){
System.out.println("父型参数");
o.show();
}
void test(Doo o){
System.out.println("子型参数");
o.show();
}
}
class Coo{
void show(){
System.out.println("父类show");
}
}
class Doo extends Coo{
void show(){
System.out.println("子类show");
}
}//输出父型参数show，子类show

 

重写需遵循"两同两小一大"原则:
* 1.两同:
* 1)方法名称相同
* 2)参数列表相同
* 2.两小:
* 1)子类方法的返回值类型小于或等于父类的
* 1.1)void时，必须相同
* 1.2)基本类型时，必须相同
* 1.3)引用类型时，小于或等于
* 2)子类方法抛出的异常小于或等于父类的------异常之后
* 3.一大:
* 1)子类方法的访问权限大于或等于父类的------访问修饰符之后
*/

 

//父类大，子类小
class Aoo{
public void show(){}
double test(){ return 0.0; }
Boo sayHi(){ return null; }
Aoo say(){ return null; }
}
class Boo extends Aoo{
//int show(){ return 1; } //编译错误，void时子类和父类必须相同
//int test(){ return 0.0; } //编译错误，基本类型(应为double)时必须相同
//Aoo sayHi(){ return null; } //编译错误，引用类型(Aoo)小于或等于
Boo say(){ return null; } //正确
//void show(){} //编译错误，访问权限必须大于等于父类的(应为public)
}

建议:
域名反写 . 项目名称 . 模块名称 . 类名
cn.tedu . manager . studentmanager . Aoo

编译期时还没有对象呢，只是检查语法是否正确，
语法错误则直接编译错误(冒红)

运行期时有对象

 

.java到.class----------------编译期
JVM加载并运行.class----------运行期