java1-12
标识符：
数字，字母，下划线，美元符号 不可以以数字开头，不可以使用Java关键字，区分大小写 类名：首字母大写，其余遵循驼峰命名法 方法名，变量名：首字母小写，其余遵循驼峰命名 包名：全部小写，不遵循驼峰命名
数据类型：
基本数据类型：byte, short, char, int, long, float, double, boolean
引用数据类型：接口，类，数组，String等非基本数据类型
包装类位于java.lang包，八种包装类和基本数据类型的对应关系：
== 的作用：
基本数据类型用（==）比较的话，比较的是值 引用数据类型用（==）比较的话，比较的是内存中的地址
equals的作用：
引用数据类型用.equals比较的是变量值
数组的创建方法：
1，int arr[] = new int[5] 动态创建 2，int a[] = new int[]{1,2,3,4,5} 动态创建 int a[] = new int[4]{1,2,3,4,5}---->错误的 Int a[]; .a= {1, 2, 3,}----->错误的 3，int[] x = {6, 7, 8, 9} 静态创建
package training;
import org.checkerframework.checker.units.qual.A;
import java.util.Arrays;
public class Arry6 {
public static void main(String[] args){
// toString对数组进行遍历查看
int[] arr = {1, 9, 5, 7};
System.out.println(Arrays.toString(arr));
// 排序
Arrays.sort(arr);
// binarySearch对有序数组查询
System.out.println(Arrays.binarySearch(arr, 9));
// copyOf 复制
int[] arr2 = {1, 3, 4, 5, 6, 7};
int[] newArr = Arrays.copyOf(arr2, 4);
System.out.println(Arrays.toString(newArr)); // [1, 3, 4, 5]
// copyOfRange区间复制
int[] newArr2 = Arrays.copyOfRange(arr2, 1, 5);
System.out.println(Arrays.toString(newArr2)); // [3, 4, 5, 6]
// equals比较2个数组是否一致
int[] arr3 = {1, 3, 4};
int[] arr4 = {1, 3, 4};
System.out.println(Arrays.equals(arr3, arr4)); //true
System.out.println(arr3 == arr4); // false, = = 比较的是地址值
// fill数组填充
int[] arr5 = {1, 4, 5, 6, 8};
Arrays.fill(arr5, 10);
System.out.println(Arrays.toString(arr5)); // [10, 10, 10, 10, 10]
int[] arr6 = {11, 22, 33, 44, 55};
int[] arr7 = new int[10];
System.arraycopy(arr6, 1, arr7, 3, 4);
System.out.println(Arrays.toString(arr7)); // [0, 0, 0, 22, 33, 44, 55, 0, 0, 0]
}
}
方法调用：
1，对象名.方法名，（非静态方法） 2，new关键字调用构造方法，这是在实例化对象时使用 3，类名.方法名，修饰符为static时（静态方法）
实例化方法：类名 对象名 = new 类名（） 对象名.方法名（）
package training;
public class InvokeMethod {
public static void main(String[] args){
//对象名.方法()进行调用
InvokeMethod in = new InvokeMethod();
in.t1();
//类名.方法名()进行调用
InvokeMethod.t2();
}
//非静态方法
public void t1(){
System.out.println("t1");
}
//静态方法
public static void t2(){
System.out.println("t2");
}
}
成员变量与局部变量
public class Person {
// 属性，成员变量，放在类中方法外
int age; // 成员变量默认有初始值，所以可以不用初始化
String name;
double height;
double weight;
public void eat(){
int num = 10; //局部变量，放在方法中，默认没有初始值，所以必须先初始化
System.out.print("I like to eat");
}
public void sleep(){
System.out.print("I like to sleep");
}
public String introduce(){
return "My name is: "+name+",My age is: "+age+",My height is: "+height+",My weight is: "+weight;
}
package test;
public class bianliang {
static int weight;//类变量，也叫静态变量，放在java堆中
final String NAME = "ERER";//常量，必须大写
int[] arry = {};//arry是成员变量，引用数据类型，不初始化时默认子为null
int age;//age是成员变量，可以不用初始化，有默认值0
public static void main(String[] args) {
bianliang.weight = 10;//静态变量直接用 ‘类名.变量名’ 调用
//System.out.println(age);这里age是成员变量，不能直接调用，要先实例化
bianliang b = new bianliang();
b.age = 20;//实例化之后可以使用成员变量
b.girl();//非静态方法需要先实列化对象，实例化方法：‘类名 对象名 = new 类名（）’
bianliang.eat();//静态方法直接用 ‘类名.方法名’ 调用
}
public void girl() {
//非静态方法
int height = 2;//height是局部变量，必须先初始化
System.out.println(age);
System.out.println(arry);
System.out.println(height);
System.out.println(NAME);
System.out.println(weight);
}
public static void eat(){
//静态方法
System.out.println("eat method");
}
}
//第一次加载类的时候，会进行类的加载，初始化对象的时候，对象的属性没有给赋值，有默认的初始化值
如果是引用类型默认初始化为null,如果是基本类型例如int则会默认初始化为0
Person p = new Person();
/* new关键字实际上是在调用一个方法，这个方法叫构造器（构造方法）
调用构造器的时候，如果你的类中没有写构造器，那么系统会默认给你分配一个构造器，只是我们不知道
[修饰符] 构造器名字（）{
}
构造器和方法的区别:
1.没有方法的返回值类型
2.方法体不能有return
3.构造器名字必须跟类名一样
构造器的作用：不是为了创建对象，因为在调用构造器之前对象已经创建好了，
并且属性有默认的初始化值，构造器的目的是为属性进行赋值操作
注意：一般不会在空构造器中进行初始化操作，因为那样的话每个对象的属性就一样了
*/
package 1_package;
public class Person {
// 空构造器
public Person(){
// age = 19;
// name = "lili";
// height = 180.0;
}
// 构造器的重载
public Person(int age, String name, double height){
this. name = name; // 等号左边的name指的是属性名，this指的就是Person的地址，就是你创建的对象，等号后面的name就是形参
this.age = age;
this.height = height;
}
// 属性，成员变量，放在类中方法外
int age; // 成员变量默认有初始值，所以可以不用初始化
String name;
double height;
double weight;
// 方法
public void eat(){
int num = 10; //局部变量，放在方法中，默认没有初始值，所以必须先初始化
System.out.print("I like to eat");
}
public void sleep(){
System.out.print("I like to sleep");
}
public String introduce(){
return "My name is: "+name+",My age is: "+age+",My height is: "+height+",My weight is: "+weight;
}
}
package 1_package;
public class Test {
public static void main(String[] args) {
//创建一个人类的具体的对象
//创建一个对象，对象的名字叫ZS
//左边的Person属于引用数据类型，接收zs
//第一次加载类的时候，会进行类的加载，初始化对象的时候，对象的属性没有给赋值，有默认的初始化值
Person p = new Person(23, "lili", 180.3);
System.out.println(p.age);
System.out.println(p.name);
System.out.println(p.height);
This
This修饰属性
public void eat(){
int age = 10; //局部变量，放在方法中，默认没有初始值，所以必须先初始化
System.out.println("----------");
// this.属性, 不发生重名的话this可以不写
System.out.println(age); //不加this的时候就是指的局部变量的age
System .out.println(this.age); //加了this指的是当前对象的属性
System.out.println("I like to eat");
}
This 修饰方法
public void sleep(){
// this.introduce();
introduce();
System.out.println("I like to sleep");
public String introduce(){
//this修饰属性时，不发生重名的话this可以不写
return "My name is: "+name+",My age is: "+age+",My height is: "+height+",My weight is: "+weight;
// return "My name is: "+this.name+",My age is: "+this.age+",My height is: "+this.height+",My weight is: "+this.weight;
}
This 修饰构造器
public class Person {
同一个类中的构造器中也可以相互用this调用，注意：this修饰的构造器必须放在第一行
public Person(int age, String name, double height){
this(age, name);
this.height = height;
}
public Person(int age, String name){
this(age); // 这里的age指的是第三个Person中的age
this.name = name;
}
public Person(int age){
this.age = age;
}
}
Static
static修饰属性
package 1_package2;
public class Test {
// 属性
int id;
static int sid;
// 创建一个main方法，是程序的主入口
public static void main(String[] args){
// 创建一个Test类的具体对象
Test t1 = new Test();
t1.id = 10;
t1.sid = 10;
Test t2 = new Test();
t2.id = 20;
t2.sid = 20;
Test t3 = new Test();
t3.id = 30;
t3.sid = 30;
System.out.println(t1.id);
System.out.println(t2.id);
System.out.println(t3.id);
// 这里输出的全都是30
// static的sid是加载到静态区了，sid是共享的
// static的sid先于对象存在
System.out.println(t1.sid);
System.out.println(t2.sid);
System.out.println(t3.sid);
// 官方推荐这种方式访问static
Test.sid = 100;
System.out.println(sid);
}
}
package 1_package2;
public class Student {
String name;
int age;
//String school;
static String school; // static修饰属性时，可以共享
public static void main(String[] args){
Student.school = "one"; // 这里所有学生的school都是one,实现了共享
Student s1 = new Student();
s1.age = 12;
s1.name = "li";
//s1.school = "one";
Student s2 = new Student();
s2.age = 23;
s2.name = "wi";
//s2.school = "one";
}
}
static修饰方法
package 1_package2;
public class Demo {
int id;
static int sid;
public void a(){
System.out.println(id);
System.out.println(sid);
System.out.println("-----");
}
public static void b(){
//this.a();//在静态方法中不能访问非静态的方法
// System.out.println(id);//在静态方法中不能访问非静态属性 System.out.println(sid);
System.out.println("-------b");
}
// static 和 public是并列的，没有先后顺序
static public void c(){
}
public static void main(String[] args){
// 非静态方法的访问可以用 对象.方法名 调用
Demo d = new Demo();
d.a();
// 静态方法可以用 对象.方法名 调用， 也可以用 类名.方法名（推荐）
Demo.b();
d.b();
}
}
类的组成：
属性， 方法， 构造器， 代码块， 内部类 代码块的分类： 普通块， 构造块， 静态块， 同步块（多线程）
代码的执行顺序：
最先执行静态块，只在类加载的时候执行一次，所以一般的实战项目，数据库的初始化信息放入到静态块中，一般用于执行一些全局的初始化操作
再执行构造块（不常用）
再执行构造器
再执行方法中的普通块
package 1_package3;
public class Test {
//属性
int a;
static int b;
// 方法
public void a(){
System.out.println("a方法开始执行");
{
// 普通块限制了局部变量的范围
System.out.println("a方法中的普通块");
int num = 10;
System.out.println(num);
}
}
public static void b(){
System.out.println("静态b方法");
}
//静态块
static{
// 在静态块中只能访问静态属性和静态方法
System.out.println("这是一个静态块");
b();
}
//构造块
{
System.out.println("这是一个构造块");
}
//构造器
public Test(){
System.out.println("这是一个空构造器");
}
public Test(int a){
this.a = a;
}
public static void main(String[] args){
Test t = new Test();
t.a();
Test t1 = new Test();
t.a();
}
}
这是一个静态块
静态b方法
这是一个构造块
这是一个空构造器
a方法开始执行
a方法中的普通块
10
这是一个构造块
这是一个空构造器
a方法开始执行
a方法中的普通块
10
Process finished with exit code 0
final关键字
修饰变量
package 1_package_final;
import 1_package2.Demo;
public class Test {
public static void main(String[] args){
// final关键字,修饰基本数据类型的时候，变量要大写
final int A = 10;
//A = 20; // 报错，不可以修改值，变量a被final修饰
// final修饰引用数据类型，地址值不可以更改
final Dog d = new Dog();
// d = new Dog(); //报错，修饰引用数据类型，地址值不可以更改
// d的对象可以被修改
d.age = 12;
d.weight = 130.0;
final Dog d2 = new Dog();
a(d2);
b(d2);
}
public static void a(Dog d){
d = new Dog();
}
public static void b(final Dog d){
//d = new Dog(); //报错，d被final修饰了，地址值不能改变
}
}
修饰方法
package 1_package_final;
public class Person {
public final void eat(){
System.out.println("I can eat");
}
}
class Student extends Person{
@Override
// final修饰方法，那么这个方法不可以被子类重写
public void eat(){
super.eat();
}
}
## 修饰类
Final修饰类，代表没有子类，该类不可以被继承
一旦一个类被final修饰，那么里面的方法也没有必要被final修饰了，可以省略不写
package 1_package_final;
public final class Person2 {
public void eat(){
System.out.println("I can eat");
}
}
class Student extends Person{
@Override
// final修饰方法，那么这个方法不可以被子类重写
public void eat(){
super.eat();
}
Math类
没有子类，不能被其他类继承 里面的属性和方法也都被final修饰了
math中的所有属性和方法都被static修饰了， 不用创建对象调用，通过（类名.属性名）和（类名.方法名）调用
投递京东等公司10个岗位 >