2.8日Java基础学习笔记

基本数据类型

数据类型	关键字	取值范围	默认值	内存占用
整数	byte	-2^7 ~ 2^7-1	0	1
	short	-2^15 ~ 2^15-1	0	2
	int	-2^31 ~ 2^31-1	0	4
	long	-2^63 ~ 2^63-1	0	8
浮点数	float	-3.401298e-38 ~ 3.402823e+38	_	4
	double	-4.9000000e-324 ~ 1.797693e+308	0.0	8
字符	char	0 ~ 65535	0.0	2
布尔	boolean	true，false	flase	1

他们的默认值可以用用下代码测试：

     public class PrimitiveType{
 
         boolean t;
         char c;
         byte b;
         short s;
         int i;
         long l;
         float f;
         double d;
 
 
         void print(){
             System.out.println("boolean  "+t);
             System.out.println("char  "+c);
             System.out.println("byte  "+b);
             System.out.println("short  "+s);
             System.out.println("int  "+i);
             System.out.println("long  "+l);
             System.out.println("float  "+f);
             System.out.println("double  "+d);
        }
 
        public static void main(String args[]){
 
             PrimitiveType pt=new PrimitiveType();
 
             pt.print();
 
        }
 
 
    }

数据类型转换

自动类型转换（隐式转换）：取值范围小的数值向取值范围大的数值转换

提升规则：

1、byte→short→int→long→float→double

2、取值范围小的和取值范围大的进行计算，小的会先提升为大的，再去进行计算

3、byte short char 三种类型的数据在运算的时候都会先提升为int，然后再去计算

强制类型转换：取值范围大的数值向取值范围小的数值转换

使用场景：如果把一个取值范围大的数值赋值给取值范围小的变量，是不允许直接赋值的，如果一定要这么做就需要加入强制转换
格式：目标数据类型变量名=(目标数据类型)被强转的数据

实例：

double a = 12.3;
int b = (int)a;

---

数组

声明：

初始化：就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程

动态初始化：手动指定数组长度，由系统给出默认初始化值。
                      只明确元素个数，不明确具体数值，推荐使用动态初始化
静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组的长度。
                      需求中已经明确了要操作的具体数据，直接静态初始化即可。

完整格式 数据类型[]数组名= new数据类型[]{元素1，元素2，元素3...};
范例：

int[]array = new int[]{ 11，22，33};
double[] array2 = new double[] { 11.1，22.2，33.3};

简化格式：数据类型[]数组名={元素1，元素2，元素3...};
范例：

int[] array = { 11，22，33};
double[]array2 = { 11.1，22.2，33.3};

声明区别：

C语言：数组的声明需要给出数组的维数

int arr[5];

Java：数组的声明能不给出数组的维数

int[] arr;

int arr[];

动态定义时给出：

arr = new int[5]

静态定义时无需给出

arr = new int[]{....};
arr={xxx};

 foreach 循环的语法格式：

for (type variableName : array | collection)//array 数组 collection 容器/集合
{	
	// variableName 自动迭代访问每个元素...
}

实例：

public static void main(String[] args){

	String[ ] books = {"Hello","World","!"};
	//使用foreach 循环来遍历数组元素
	//其中 book 将会自动迭代每个数组元素
	for(String book : books){
		System.out.println(book);
	}
}

注意：使用 foreach 循环迭代数组元素时，并不能改变数组元素的值，因此不要对 foreach 的循环变量进行赋值。

---

方法（函数）

主方法解读：

关键字public： 公共状态，权限修饰符，所有情况都可以访问

 主方法是jvm虚拟机直接调用的，语言之间相互调用，需要使用最大的最高的权限

关键字static：静态状态，在不创建对象的前提下也可以访问

 主方法是jvm虚拟机直接调用的，测试类中，不需要定义成员变量，也不需要有对象存储数据，可以直接调用主方法，主方法没有必要声明为非静态；jvm是C语言写的，是一个面向过程的语言，不能创建对象。

关键字void：空，返回值类型为空

 主要使用java语言操作各种数据，如果主方法有返回值，返回给调用者（jvm虚拟机），返回给jvm虚拟机之后，我们没有办法操作这个数据了，没有任何意义。

main方法：主要的，不是一个关键字

 在jvm虚拟机中，要执行某个类的时候，只执行main方法，在jvm的代码中，已经将要访问的方法，程序的唯一入口，写死了

String[] args形式参数：字符串类型的数组

在执行主方法的时候，可以传入一些参数，将来在主方法中，可以接收到这些参数

 Args是一个参数名称，任意修改

声明方法方式：

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。

返回值类型 ：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。

方法名：是方法的实际名称。方法名和参数表共同构成方法签名。

参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

实例：

/** 返回两个整型变量数据的较大值 */
public static int max(int num1, int num2) {
   int result;
   if (num1 > num2)
      result = num1;
   else
      result = num2;
 
   return result; 
}

//简化写法（三元运算符）
public static int max(int num1, int num2) {
  return num1 > num2 ? num1 : num2;
}

方法调用：

public class TestMax {
   /** 主方法 */
   public static void main(String[] args) {
      int i = 5;
      int j = 2;
      int k = max(i, j);
      System.out.println( i + " 和 " + j + " 比较，最大值是：" + k);
   }
 
   /** 返回两个整数变量较大的值 */
   public static int max(int num1, int num2) {
      int result;
      if (num1 > num2)
         result = num1;
      else
         result = num2;
 
      return result; 
   }
}

---

面向对象起步

类和对象的关系

类其实就是一个模板，比如说类就好比一张房子的设计图纸，或者说是一个倒印模具，创建一个类就好比设计一张图纸，刻一个模板。对象就好比一座建好的房子，一个成型的模型，无疑想要一座房子或者一个模型都先需要一张图纸和一个模板，而这就是类和对象的关系

封装

定义：在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法，封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问，要访问该类的代码和数据，必须通过严格的接口控制

作用：封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段，适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性

继承

定义：继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为

作用：代码存在重复了，导致后果就是代码量大且臃肿，而且维护性不高(维护性主要是后期需要修改的时候，就需要修改很多的代码，容易出错)，所以要从根本上解决这两段代码的问题，就需要继承，将两段代码中相同的部分提取出来组成 一个父类

多态

定义：多态是同一个行为具有多个不同表现形式或形态的能力

作用：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理

局部变量：

局部变量是在方法、构造函数或块内部声明的变量，它们在声明的方法、构造函数或块执行结束后被销毁，局部变量在声明时需要初始化，否则会导致编译错误。

public void exampleMethod() {
    int localVar = 10; // 局部变量
    // ...
}

成员变量（实例变量）：

实例变量是在类中声明，但在方法、构造函数或块之外，它们属于类的实例，每个类的实例都有自己的副本，如果不明确初始化，实例变量会被赋予默认值（数值类型为0，boolean类型为false，对象引用类型为null）。

public class ExampleClass {
    int instanceVar; // 实例变量
}

构造方法

定义：构造方法呢，就是一种特殊的方法，每当一个类被实例化的时候，就会调用构造方法，而且只有构造方法被调用的时候，对象才会被分配内存空间。

声明：

1、构造方法的名字必须和类名一致
2、构造方法没有返回值，返回的是一个类
3、构造方法不能是抽象的，静态的，最终的，同步的也就是说，他不能通过abstract，static，final，synchronized关键字修饰，就是由于构造方法是不能被继承的，所以final和abstract是没有意义的，而且他是用于初始化一个对象的，所以static也是没有用的，多个线程也不会同时去创建内存地址相同的对象，所以也是没有意义的

public class people {
    private String name;
    private int age;
    
    //无参构造
    public people() {
    }
    //有参构造方法
    public people(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

无参的构造函数

在Java中，如果一个类没有定义任何构造函数，那么编译器会默认为这个类提供一个无参的构造函数。 这个隐式的构造函数在继承的时候，子类会在自己的构造方法里面默认的调用这个构造函数。