Java编程基础详解-优快云博客

本文链接：https://blog.youkuaiyun.com/I_AM_KK/article/details/77867889

代码：源代码
存放代码的文件：源文件
java代码—编译工具javac—字码节文件（class文件）–启动不同平台JVM
开始程序过程
语法：javac 文件名.java; //编译过程（生成 .class文件）
java 类名； //执行过程
java区分大小写；
源文件中有几个类就会生成几个class文件；
public类存在时，文件名必须和其一样；（没有public时文件名可以不一样）
public只能存在一个；
开头必须是pubic static void main（String[] args）;
注释
1 //
2/* /
3/* */ 文档注释，会生成文档；
成员变量（全局）；
局部变量（{}内有效）；
数据类型
一 .基本数据类型 共8个
1 数值型整数byte 1字节，shor 2字节， int 4字节.，long 8字节（最好以L结尾），小数 float 4 字节（结尾必须加F），double 8字节（小数默认类型）;
2 字符型 char（'A’或’恩’或ASCII表数字） 2字节；
3 布尔型 boolean (true flase) 1字节；
二.引用数据类型/对象数据类型
类/接口/数组
二进制 0b开头；
八进制 0开头；
十六进制 0x开头；
String 字符串 “abcde”；
String = “我今年”+“15岁”；
字符串与任何数+（连接）都是字符串；
强制类型转换
double f1 = 4.00000;
float f2 = (float) f1 ;
int = (int) (3+5.00);
整数默认是int类型；当整数赋值给byte时，系统自动判断并转换赋值；在表达式中会自动提升类型（byte short char 自动转换成 int，其余有最高的转换成最高的）；故：byte b = 25;
b = b+5;错误（b是byte，5是int）
程序异常会中断程序，异常后面的程序不执行；
infinite正无穷大；正浮点数除以0 或正整数除以0.0时；—System.out.println(100 .0/ 0);
.infinite正无穷大；负浮点数除以0 或负整数除以0.0时；—System.out.println(-100.0 / 0);
NaN(not a number)—System.out.println(0.0 / 0.0);
double a = 0.0 / 0.0;a == a;这个算式是 flase;
5 % 2 (1);-5 % 2（-1）； 5 % -2 (1);-5 % -2（-1）；
i = 5;
i++ =6;++i = 6;
i = 5;
a = i++ a=5 i=6; a = ++i ;a=6 i=6;
+= 中含有隐式转换，几乎不会存在精度从高到低转换；
三元运算符
int a = 5;
int b = 10;
int c = a > b ? a : b;
& | ^ !用在二进制上；&& || ! ^{都可以用，并且先算前面，如果成立则不继续运行；连续两次}值不变；
switch 语句语法:
int weekday = 7;
switch(weekday)
{
case 1:System.out.println("…");break;
case 2:System.out.println("…");break;
case 3:System.out.println("…");break;
case 4:System.out.println("…");break;
…
default:System.out.println("…");
}//case后面一般是常量
break语句结束当前循环；continue是跳过当前的一次循环；return是结束当前的方法；可以给break结束的循环加名字用来跳出指定的循环；例如：
**outer ?*for(i=1;i<10;i++)
{
for(j=1;j<9;j++)
{
if(k==5)
{
break outer;
}
System.out.println(“hhhhh”);
}
}
方法定义：
[修饰符] 返回值类型方法名称（参数）
{
方法体；
[return 值];
}
类class是java最小的单位；可以在类里定义函数，然后调用解决重复代码的问题 ----类名.函数名；
有返回值时，要定义变量接收函数的返回值，然后输出变量；
例：int x = A.doWork( , );
System.out.println(x);
关系重载时，方法名相同，参数不同，且和返回类型无关，可以存在在方法里；并且当参数不同时精度低的会提升精度进入参数列表，精度高的不能进入精度低的，会报错；
数组初始化
静态分配
int[] nums = new int[]{1,2,3,4,5,6};//重新分配时只需 nums = new int[]{1,2,3};
int[]nums = {1,2,3,4,5,6};//必须定义好就初始化
动态分配
int[] nums = new int[3];//重新分配时只需 nums = new int[10];
二维数组
静态初始化
int[][] arr = new int[][]{ {1,2,3},{4,5},{6} };
其下标表示为 arr[0][0] arr[0][1] arr[0][2] arr[1][0] arr[1][1] arr[2][0];
动态初始化
int[][] arr = new int[3][5];
for循环新增加的语法专门输出数组；//编译器的功能，发编译在底层时依然是索引；
例：for (int ere:nums)
{
System.out.println(ele);//打印出来的就是数组值；
}
方法的可变参数；//参数数量可以变成动态的//编译器的功能，发编译在底层时依然是数组；
例：public static void main(sting args[])
{
double sum = getSum(10,20,30);//精髓在于参数个数随便写
System.out.println(sum);
}
static double getSum(double … arr)//就是参数任意的意思等价于double[] arr
{
double sum = 0.0;
for(double price: arr)
{
sum += price;
}
return sum;
}
System类中的arraycopy方法
System.arraycopy(Object src,int srcPos,Object dest,int destPos,int length);//参数列表的含义：源数组，源数组起始位置，目标数组，目标数组起始位置，要复制数组的长度；Object是所有类型都可以的意思；
例：System.arraycopy(src,2,dest,5,4);
排序搜索
冒泡排序：两两比较，大的交换继续两两比较，每一次都能得到最大值；下一轮除去最后一个后，继续冒泡，n-1次后完成；
选择排序：第一个和后面依次比较，小的提出，和后面继续比，直到比完最后一个找到最小值并放在开头，下一轮从第二个开始，继续选择排序，n-1次后完成；
二分查找：前提是数组有序，无序先排序；当low<=hight时，执行取中间值和关键值比较，如果大，则执行取中间值继续比较，如果小，则执行取中间值比较，如果相等则返回索引；否则返回-1，表示找不到；
java内置数组工具类Arrays:里面集合了数组的各种操作，可以直接应用；但是用的时候要先找到java中的包，例如 java.util.Array.sort(arr,2,6);//表示从arr数组索引2,3,4,5排序，区间前闭后开；另共有八大类型，每个类型有一个重载，共十六个，排序时可以全部排序，也可以指定从几到几排序；后期补齐
面向对象和面向过程的区别：前者是是狗吃屎，后者是狗在吃屎；
面向对象的三个特征：封装、继承、多态；
类可以制造很多对象；
类的定义：
[修饰符] class 类名
{
成员变量；
方法；
}//注意事项如果使用了public修饰，必须保证当前文件名称和当前类名相同；
创建对象：
类名变量 = new 类名（）；引用成员时用 . ;
new在堆分配空间，对象名在栈中使用，方法存在方法区；
类定义和类数组
例：class Student()
{
String name;
boolean fee;
{
isfee = true;
}
}
Student s1 = new Student();//开辟对象的空间
Student s2 = new Student();
Student s3 = new Student();
Student s4 = new Student();
Student [] arr = new Student() {s1,s2,s3,s4};//其实是把类的首地址传给数组，for循环的时候，变量值是地址，必须用变量.成员使用
构造器是为了创建对象创建对象必须和new一起使用；完成对象的初始化操作；构造器名称和当前类相同；禁止定义返回类型；不需要使用return返回值，默认返回类的类型；
例：class student//如果用public修饰
{
}
构造过后 class student
{
student () {}//也用public修饰
}
自己定义构造过后 class student
{
student (String name) {}//也用public修饰
}
Student s1 = new Student();
Student s2 = new Student(“张三”);
构造器只有在类中没有定义方法的时候自动调用（new的时候就是调用构造器），如果自己定义的方法，则不调用，会自己加载；当自己定义方法时允许参数不同的重载（可以用this语句解决构造器重载相互调用问题，能且只能一次在首行指代；少参调用多参）；
在这里单独解释一下this 在同一个类的字段和方法使用时，可以理解为：方法的参数传给每一个实例过的this参数（这里的this有两种理解1 this是类的东西先赋值后实例化中带this也就是对象的 2先实例化对象，this是对象的东西，不过这东西是从类里来的，后面的是方法的参数；第二种正解） 在子类父类等不同类中，可以理解为：当前类中的方法，而不是其他类中的，这和第二解释不谋而合；
34.static修饰类级别不是对象级别；随着类的加载就加载了，优先于对象存在；所有对象共享；直接使用类名访问static成员，(如果使用对象名调用，结果也是类的调用)；class person()
{
static int num = 0;
}
person p1 = new person();
person p2 = new person();
System.out.println(person.num); //System.out.println(p1.num)得到相同结果
static方法只能调用static成员，非static方法能调用static成员也能调用非static成员；有static修饰的成员是实例成员，没有static修饰的成员是类成员；
成员变量有默认初始值；局部变量（{}内的变量）必须自己初始化才能使用；
packet关键字，类似于文件夹的意思，用于打包java文件，方便管理；放在代码首行，编译时把字节码文件放在此包名的文件夹里（没有packet时直接在当前目录里建立字节码文件）；（命令格式也变为packet -d . 类名）语法：
packet 包名.子包名.子子包名；//以此类推
具体实例 packet 域名倒写.模块名.组件名；
37.1 import关键字，用于把包中所有的类导入到当前文件中；（java会默认导入java.lague的类）
例：原本 java.util.Arrays.sort(arr);
java.util.Arrays.sort(arr);
现在开头写 import java.util.Arrays;//表示把java中utli包中的Arrays类导入到文件中
使用 Arrays.sort(arr);
Arrays.sort(arr);
2若是需要引用很多个类
import java.util.Arrays;
import java.util.Set;
import java.util.List;
则可以使用通配符 * import java.util.*;
3若是想直接引用方法名，则使用static，；例 import static java.util.Arrays.sort；//以后可以直接使用sort
封装 pravite protected public
把成员变量和方法放在一个类里，把参数也放在一个类里，隐藏信息，提高安全；提高数据安全还可以把数据设为pravite 然后增加方法，调用方法更改成员值；//通常使用set 函数和get函数；
public class Person
{
private String name;
private int age;
//例
public String getName()
{
return name;
}
public void setName(String n)
{
name = n;
}
}
this 用法主要用在传参与字段相同的情况
public class Person
{
private String name;
private int age;
//例
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;//当前name的值赋值给字段this.name
}
}
继承extends,默认继承Object类（所以物体的意思）
class Father//父类公共拥有的属性和属性
{
String name;
int age;
public void sleep(){};
}
class Son extends Father //子类只写自己拥有不同的部分
{
Sring sn;
}
继承注意事项：1java中不允许多继承，允许一个一个继承；2public,protected,缺省子类可以直接继承父类，private子类继承不了父类（属性只能本父类访问），子类不能继承父类的构造器（构造器的名字必须和当前类名相同）；
当父类方法不适用子类时，可以在子类中自己定义一个方法，称为方法覆盖，程序先搜索子类方法再搜索父类方法；例
class Father
{
String name;
int age;
public void sleep()
{Syatem.out,println(“hahaha”)};
}
class Son extends Father
{
Sring sn;
public void sleep()
{Syatem.out,println(“lalala”)};
}
注意事项：方法名必须相同，参数必须相同，返回值相同或者是子类的类型，子类访问权限大于等于父类
super表示上一级的意思，所以指父类；
1 子类父类都有相同某字段或方法时，会就近原则调用子类，此时如果还想用父类需使用 super;//this是子类，super是父类。this.name,super.name;this.Fly(),super.Fly();
2 子类实例化对象时会先调用父类构造器，在调用子类构造器，默认调用无参构造器，所以默认使用了super语句，当父类构造器是自己定义的时候，则需自己写出super语句，super([实参]);
Object类是根类，所以的类/借口/数组都有一些方法，比如
int hashCode() 返回对象哈希码值 //name.hashCodez()
boolean equals() 返回地址是否相等（但大多数我们比较内容是否相同）//s1.equals(s2)
String toString() 把一个对象转换成字符串
多态例子类继承父类
class Animal
{
…
}
class Dog extengs Animal
{
…
}
class Cat extends
{
…
}
原本 Dog d = new Dog();
Cat c = new Cat();
其实可以 Animal d = new Dog();
Animal c = new Cat();
当定义一个方法A使用父类的方法时，里面的参数可以使用父类类，在子类调用A时可以不关心子类的不同点，使用同一个方法；（传参的时候具体而定）
引用类型转换
自动类型转换 Animal d = new Dog();
强制类型转换Dog d = (Dog) a; //会报错
使用到instanceof ，a instanceof b运算符判断对象a是否是类b的实例
然后转换且只能Animal d = new Dog(); Dog b = ( Dog)d;

java粗略笔记