时隔4个月,终于完成了一些重要事情,又有时间学习JAVA了,但基础有些遗忘,复习一下吧,再进行下阶段的学习
不管结果,学习就好
Java重要特点:
1.Java语言是面向对象的(oop)
2. Java语言是健壮的。Java的强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证
3.Java语言是跨平台性的。[即:一个编译好的.class文件可以在多个系统下运行,这种特性.称为跨平台]
4.Java语言是解释型的[了解]
解释性语言:javascript,PHP, java 编译性语言; c/ c++
区别是:解释性语言,编译后的代码,不能直接被机器执行,需要解释器来执行,编译性语言,编译后的代码,可以直接被机器执行, c/c++
JVM:解释工作,翻译,和执行
JVM包含在JDK中
Java运行机制及运行过程
Java核心机制-Java虚拟机[JVM java virtual machine]√基本介绍
1)JVM是一个虚拟的计算机,具有指令集并使用不同的存储区域。负责执行指令,管理数据、内存、寄存器,包含在K中.
2)对于不同的平台,有不同的虚拟机。
3) Java虚拟机机制屏蔽了底层运行平台的差别,实现了“一次编译,到处运行”
什么是JDK。JRE
JDK基本介绍
1.JDK的全称(Java Development Kit Java开发工具包)
JDK = JRE + java的开发工具[java, javac,javadoc,javap等]
2. JDK是提供给Java开发人员使用的,其中包含了java的开发工具,也包括了JRE 所以安装了JDK,就不用在单独安装JRE了。
JRE 基本介绍
1.JRE(Java Runtime Environment Java运行环境)
JRE = JVM + Java的核心类库[类]
2.包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库等
如果想要运行一个开发好的Java程序,计算机中只需要安装JRE即可。
什么是JD.K,JRE
JDK、JRE和JVM的包含关系
·1.JDK = JRE+开发工具集(例如Javac,java编译工具等)2.JRE= JVM+ Java SE标准类库(java核心类库)
3.如果只想运行开发好的.class文件只需要JRE
package review;
public class review_one {
public static void main(String[] args){
System.out.println("hello,复习要快点完成");
}
}
调用方法时,需要先实例化
例:
re one = new re();
one.ti();
package review;
public class review_one {
public static void main(String[] args){
System.out.println("hello,复习要快点完成");
review_one one=new review_one();
one.change();
}
public void change(){
System.out.println("hjhj\tjdjjh\t");
}
}
输出双引号要用转义字符
初学java易犯错误
1.找不到文件
解决方法:源文件名不存在或者写错,或者当前路径错误
2主类名和文件名不一致
解决方法:声明为public的主类应与文件名一致,否知编译失败
3.缺少分号
解决方法:编译失败,注意错误出现的行数,再到源代码中指定位置改错。
文档注释
/**
- @author 兴丽
- @version 1.0
/
Java代码规范
1.类、方法的注释,要以javadoc的方式来写。
2.非Java Doc的注释,往往是给代码的维护者看的,着重告述读者为什么这样写,如何修改,注意什么问题等
3.使用tab操作,实现缩进,默认整体向右边移动,时候用shift+tab整体向左移4.运算符和=两边习惯性各加一个空格。比如:2+45+ 345 -89
5.源文件使用utf-8编码
6.行宽度不要超过80字符
7.代码编写次行风格和行尾风格(!)
变量使用注意事项
1.变量表示内存中的一个存储区域[不同的变量,类型不同,占用的空间大小不同,
比如: int 4个字节,double就是8个字节,先有基本印象,后面说字节]
2.该区域有自己的名称[变量名]和类型[数据类型]
3.变量必须先声明,后使用,即有顺序
4、该区域的数据/值可以在同一类型范围内不断变化5.变量在同一个作用域内不能重名
6.变量=变量名+值+数据类型,这一点请大家注意。变量三要素·
程序中+号的使用
1.当左右两边都是数值型时,则做加法运算
2.当左右两边有一方为字符串,则做拼接运算
只要有一边是字符串,就做拼接,运算从左到右
整数类型
整型的使用细节IntDetail.java
- Java各整数类型有固定的范围和字段长度,不受具体OS[操作系统]的影响,以
保证java程序的可移植性。 - Java的整型常量(具体值)默认为int型,声明long型常量须后加 l 或 L
- java程序中变量常声明为int型,除非不足以表示大数,才使用long
·4.bit:计算机中的最小存储单位。byte:计算机中基本存储单元,1byte = 8 bit。
float类型后面要加“f”或“F”
查看API文档:
https://www.matools.com/api
删除行:Ctrl+k
强制转换:
基本数据类型和String类型的转换
·注意事项
1.在将String类型转成基本数据类型时,要确保String类型能够转成有效的数据,比如我们可以把"123”,转成一个整数,但是不能把"hello”转成一个整数
2.如果格式不正确,就会抛出异常,程序就会终止,这个问题在异常处理寓节中,会处理
关系运算符
关系运算符细节说明
1)关系运算符的结果都是boolean型,也就是要么是true,要么是false.2)关系运算符组成的表达式,我们称为关系表达式。a>b
3)比较运算符"==“不能误写成”="
package review;
public class review_one {
public static void main(String[] args){
// System.out.println("hello,复习要快点完成");
review_one one=new review_one();
// one.change();
// one.mathvo();
one.andand();
}
public void change(){
System.out.println("hjhj\tjdjjh\t");
System.out.println("hdjsfj\r jjfj");
}
public void mathvo(){
int j = 5;
System.out.println("j=" + j + "\n" + "i = " + j );
}
public void andand(){
int a = 60;
if (a > 20 && a < 90){
System.out.println("ok100");
}
if (a > 20 & a < 70){
System.out.println("ok200");
}
int i = 8;
int k = 9;
if (i < 1 && ++k < 52){
System.out.println("ok300");
}
System.out.println("i = " + i + " " + "k = " + k);
if (i < 1 & ++k < 52){
System.out.println("ok300");
}
System.out.println("i = " + i + " " + "k = " + k);
}
public void oror(){
int a = 60;
if (a > 20 || a < 30){
System.out.println("ok100");
}
if (a > 20 | a < 30){
System.out.println("ok200");
}
int i = 8;
int k = 9;
if (i > 1 || ++k > 4){
System.out.println("ok300");
}
System.out.println("i = " + i + " " + "k = " + k);
if (i > 1 | ++k > 4){
System.out.println("ok300");
}
System.out.println("i = " + i + " " + "k = " + k);
}
赋值运算
运算符优先级
1.运算符有不同的优先级,所谓
优先级就是表达式运算中的运算顺序。如右表,上一行运算符总优先于下一行。
·2.只有单目运算符、赋值运算符是从右向左运算的。
输入:
import java.util.Scanner;
public void input_java(){
Scanner scanner = new Scanner((System.in));
System.out.println("请输入:");
String name = scanner.next();
System.out.println("请输入年龄:");
int age = scanner.nextInt();
System.out.println("薪水:");
double sal = scanner.nextDouble();
System.out.println(name + " " + age + " " + sal);
}
进制转换:
while循环控制
●基本语法
·循环变量初始化;
while(循环条件){
循环体(语句);循环变量迭代;
}
·说明
- while循环也有四要素
2)只是四要素放的位置,不一样.
public void del(){
int i = 1;
while(i <= 100){
if (i%3 == 0){
System.out.println(i + "\n");
}
i++;
}
}
answer = Scanner.next().ChartAt(0)
public void stars(){
int total = 6;
for (int i = 1; i <= total ;i++){
for (int k= 1;k <= total - i; k++){
System.out.print(" ");
}
for (int j = 1; j <= 2*i - 1 ;j++){
if (j == 1 || j == 2*i - 1 || i==total){
System.out.print("*");
}else{
System.out.print(" ");
}
}
System.out.print("\n");
}
}
return跳出方法,如写在main中,表示结束程序
数组的定义方式:
int[] a= new int[6];
int aa[] = new int[56];
int aaa[] = {12,45,12}
1.数组是多个相同类型数据的组合,实现对这些数据的统一管理
2.数组中的元素可以是任何数据类型,包括基本类型和引用类型,但是不能混用。3.数组创建后,如果没有赋值,有默认值int 0, short 0, byte 0, long 0, float 0.0,double 0.0, char \u0000,boolean false, String null
4.使用数组的步骤1.声明数组并开辟空间2给数组各个元素赋值3使用数组5.数组的下标是从0开始的。
6.数组下标必须在指定范围内使用,否则报:下标越界异常,比如
int[]arr=new int[5];则有效下标为0-4
7.数组属引用类型,数组型数据是对象(object)
将arr1拷贝到arr2,arr2开辟一个新的空间:
int[] arr1 = {12,14,62}
int[] arr2 = new int[arr1.length()]
数组扩容:
int[] arr1 = {1,2,3}
int[] arr2 = new int[arr1.length + 1]
字符串的比较用equals
//字符串比较
public void stringstring(){
String[] a = {"白天","黑夜","你好","班级"};
Scanner scan = new Scanner(System.in);
System.out.print("请输入你要查找的:");
String name = scan.next();
int index = -1;
for (int i = 0;i < a.length; i ++){
if (name.equals(a[i])){
index = i;
System.out.print("要查找的字符存在,索引为:" + index);
break;
}
}
if(index == -1){
System.out.print("Sorry!");
}
}
多维数组定义方式:
1.
int[][] arr = {{1,1,1};{1,1,1,};{1,1,1}}
2.
int a[][] = new int[2][3];
2.
int arr[][]
arr = new int[2][3]
3.
动态开辟空间
int[][] arr = new arr[3][]
for(int i = 0; i <arr.length;i++){
arr[i] = new int[i + 1]
}
二维数组的内存形式:
动态数组:
开辟空间
public void sport(){
int[][] arr = new int[3][];
for (int i = 0;i < arr.length; i ++){
arr[i] = new int[i+1];
for(int j = 0; j<arr[i].length;j++){
arr[i][j] = i+1;
}
}
for (int i = 0;i <arr.length; i++){
for (int j = 0; j < arr[i].length;j++){
System.out.print(arr[i][j] + " ");
}
System.out.print("\n");
}
}
杨辉三角
//杨辉三角
public void yanghui(){
int[][] yang = new int[10][];
for (int i = 0;i <yang.length; i ++){
yang[i] = new int[i + 1];
for (int j = 0; j < yang[i].length; j ++){
if (j ==0 || j == yang[i].length - 1){
yang[i][j] = 1;
}else{
yang[i][j] = yang[i-1][j] +yang[i-1][j-1];
}
}
}
for (int i = 0;i < yang.length; i ++){
for (int j = 0; j < yang[i].length; j ++){
System.out.print(yang[i][j] + " ");
}
System.out.println("\n");
}
}
类与对象
使用现有技术解决
1)单独的定义变量解决
2)使用数组解决
现有技术解决的缺点分析
不利于数据的管理
效率低
类与对象。
属性/成员变量
√基本介绍
1.从概念或叫法上看:成员变量=属性= field(字段)(即成员变量是用来表示
属性的,授课中,统一叫属性)
2属性是类的一个组成部分,一般是基本数据类型,也可是引用类型(对象,数组)。
比如我们前面定义猫类的int age就是属性
√注意事项和细节说明
1)属性的定义语法同变量,示例:访问修饰符属性类型属性名;
访问修饰符:控制属性的访问范围
有四种访问修饰符 public, proctected,默认,private
2)属性的定义类型可以为任意类型,包含基本类型或引用类型
3)属性如果不赋值,有默认值,规则和数组一致。具体说: int 0, short 0.byte 0, long 0, float 0.0,double 0.0,char \u0000, boolean false,String null
类的创建:
1.
Cat cat;
cat = new Cat();
2.
Cat cat = new Cat();
package review;
public class review_two {
public static void main(String[] args){
Cat cat1 = new Cat();
cat1.name = "小白";
cat1.age = 23;
cat1.color = '白';
Cat cat2 = cat1;
System.out.println(cat2.name);
}
}
class Cat{
String name;
int age;
char color;
}
类与对象。
类和对象的内存分配机制
√ Java内存的结构分析
1.栈:一般存放基本数据类型(局部变量)2.堆:存放对象(Cat cat,数组等)
3.方法区:常量池(常量,比如字符串),类加载信息
方法使用:
public static void main(String[] args){
review_two p1 = new review_two();
int mm = p1.getSum(10,20);
System.out.println(mm);
}
public int getSum(int num1, int num2){
int res = num1 + num2;
return res;
}
复用方法:
int[][] arr = {{1,5,6},{4,6,8},{4,5,1}};
MyTools tools = new MyTools();
tools.printArr(arr);
class MyTools{
public void printArr(int[][] map){
for (int i = 0; i < map.length; i ++){
for (int j = 0; j <map[i].length; j ++){
System.out.print(map[i][j] + "\t");
}
System.out.print("\n");
}
}
}
跨类调用
package review;
public class review_two {
public static void main(String[] args){
// Cat cat1 = new Cat();
// cat1.name = "小白";
// cat1.age = 23;
// cat1.color = '白';
// Cat cat2 = cat1;
// System.out.println(cat2.name);
int[][] arr = {{1,5,6},{4,6,8},{4,5,1}};
// review_two p1 = new review_two();
// int mm = p1.getSum(10,20);
// System.out.println(mm);
MyTool1 mm = new MyTool1();
mm.m(arr);
}
public int getSum(int num1, int num2){
int res = num1 + num2;
return res;
}
}
class Cat{
String name;
int age;
char color;
}
class MyTools{
public void printArr(int[][] map){
for (int i = 0; i < map.length; i ++){
for (int j = 0; j <map[i].length; j ++){
System.out.print(map[i][j] + "\t");
}
System.out.print("\n");
}
}
public void SayOk(int[][] k){
printArr(k);
System.out.print("继续执行------");
}
}
class MyTool1{
public void m(int[][] f){
MyTools b = new MyTools();
b.SayOk(f);
}
}
以上图中的两个问题的值都会变化
package review;
public class review_three {
public static void main(String[] args){
B b = new B();
int[] a = {1,4,6};
b.test100(a);
System.out.print("main中的数组:");
for (int i = 0; i < a.length; i++){
System.out.print(a[i] + "\t");
}
}
}
class B{
public void test100(int[] arr){
arr[0] = 50;
System.out.print("B类中的数组:");
for (int i = 0; i < arr.length; i++){
System.out.print(arr[i] + "\t");
}
}
}
修改对象
package review;
public class review_three {
public static void main(String[] args){
B b = new B();
int[] a = {1,4,6};
Person n = new Person();
n.name = "nkaje";
n.age = 12;
b.test200(n);
System.out.print("main中的name和age" +" " + n.name + " " + n.age);
}
}
class Person{
String name;
int age;
}
class B{
public void test200(Person p){
p.age = 12546;
}
}
对象的克隆
package review;
public class review_three {
public static void main(String[] args){
Person p = new Person();
p.name = "lili";
p.age = 56;
MyTools3 tools4 = new MyTools3();
Person p2 = tools4 .copyPerson(p);
System.out.println(p.age + " " + p.name);
System.out.println(p2.age + " " + p2.name);
System.out.println(p == p2);
}
}
class Person{
String name;
int age;
}
class MyTools3{
public Person copyPerson(Person p){
Person p2 = new Person();
p2.name = p.name;
p2.age = p.age;
return p2;
}
}
递归机制:
方法递归调用
递归重要规则
1.执行一个方法时,就创建一个新的受保护的独立空间(栈空间)2.方法的局部变量是独立的,不会相互影响,比如n变量
3.如果方法中使用的是引用类型变量(比如数组),就会共享该引用类型的数据.
4.递归必须向退出递归的条件逼近,否则就是无限递归,出现
StackOverflowError,死龟了:)
5.当一个方法执行完毕,或者遇到return,就会返回,遵守谁调用,就
将结果返回给谁,同时当方法执行完毕或者返回时,该方法也就执行完毕。
package review;
public class review_four {
public static void main(String[] args){
recurrion f = new recurrion();
int num = f.fibonacci(5);
if (num == -1){
System.out.print("无效");
}else{
System.out.print(num);
}
}
}
class recurrion{
public int fibonacci(int n){
if (n>=1) {
if (n == 1 || n == 2) {
return 1;
} else {
return fibonacci(n - 1) + fibonacci(n-2);
}
}else{
return -1;
}
}
}
桃子:
package review;
public class review_four {
public static void main(String[] args){
Peach p = new Peach();
int num = p.peach_one(9);
System.out.print(num);
}
}
class Peach{
public int peach_one(int day){
if(day >= 1){
if (day == 10){
return 1;
}else{
return (peach_one(day + 1) + 1) *2;
}
}else{
return -1;
}
}
}
JAVA同一类中,允许有同名方法存在,但要求形参不一样。