[学习交流] java基础学习交流

* 两种主流的编程思想：（还有一种编程思想：面向结果）
 * 面向过程：关注程序实现功能的每一个步骤; 典型的代表语言：c语言
 * 面向对象：不关注程序实现功能的具体步骤，关注程序所实现的功能；（关注的是对象，调用对象实现功能）
* 面向对象的编程思想来源于现实事物；
* 面向对象的三大特性：
* 封装 Object(对象)：
* 继承 Extends
* 多态
* 类：是一组相关属性和行为的集合；
* 属性：类的描述信息；
* 行为：类的所能做的事情；
*
* 类是对象的模板，对象是类的实体；
* 类是对一类事物的描述，是抽象的；
* 对象是一类事物的实例，是具体的；
*
*
* 类的定义：
* 一组具有相关属性和行为的集合；（抽象的）
* {
* 1.属性：--> 类的成员变量
* 成员变量不是定义在类中，非局部变量；
* 局部变量：1.定义在方法的内部；2.作为方法的参数；--作用域：定义开始，到所属的那对{}结束；
*
* 2.行为：--> 类的成员方法
*
* 修饰符(public) 返回值类型方法名(){
* 方法体；
* return 返回值类型；
* }
* public void study(){
* System.out.println("Study");
* }
* }
*
* 注意事项：
* 1.成员变量是指定定义在类当中的，方法外的（作用域：整个类当中）；
* 2.成员方法不需要static关键字；
*
*
* 类的使用3步走：
* 1.导包：（建议系统提示后enter，系统导包，不建议自己手动导包）
* import 包名称.类名称；
* import com.csp.day06.demo01.student;
* 对于和当前类属于同一个包的情况下，可以省略导包语句不写；
*
* 2.创建类的对象，格式：
* 类名称对象名 = new 类名称();
* student stu = new student();
*
* 3.使用，分为两种情况（通过对象调用类的成员变量或者成员方法）；
* 成员变量的使用：对象名.成员变量名;
* 成员方法的使用：对象名.成员方法名(参数列表);
*
*
* 注意事项：如果成员变量没有赋值，那么将会有一个默认值，和数组的规则一样；
* {
* 整型--0
* 浮点型-0.0
* 字符型-/u0000
* 布尔类型 false
* 引用数据类型 null
* }
*
*
* ***对象的内存图：注意和数组的内存图进行对比分析
* 1.一个对象的内存图：
* 2.二个对象的内存图
* 3.二个（对象）引用指向同一个对象的内存图
*
*注意：当一个对象作为参数，传递到方法当中时，实际传递的是对象的地址值。
* 案例：
* public class PhoneParame{
* public static void main(String [] args){
* Phone phone = new Phone();
* phone.brand = "苹果";
* }
* public static void method(Phone paramete)
* }
*
* 注意：当一个对象作为方法的返回值时，返回的其实是该对象的地址值；
* 案例：
* public class Phone{
* //成员变量
* String brand ;
* double price ;
* String color;
* //成员方法
* public void call(String who){
* System.out.println("call"+who);
* }
*
* public void sendMessage(){
* System.out.println("sendMessage everyOne");
* }
*
* }
* public class Demo05PhoneReturn{
* public static void main(String []args){
* Phone two = getPhone();
* }
* public static Phone getPhone(){
* Phone one = new Phone();
* one.brand = "苹果";
* one.price = 8388;
* ont color = "黑色";
* return one ;
* }
* }
*
* 成员变量和局部变量的区别：
* 1.位置不同：
* 局部变量：定义在方法内部或者作为方法的参数；
* 方法被调用，必然会被赋值，且必须传和参数类型相匹配的数据值；
*
* 成员变量：定义在类中，方法外；
* 2.作用的范围不一样：作用域
* 局部变量：只有方法当中才可以使用，出了方法就不能使用；
* 成员变量：整个类全部都可以通用；
*
* 3.局部变量：没有默认值，必须先赋值才能被使用；（variable not initialized）
* 成员变量：有默认值，规则和数组一样；
*
* 4.内存的位置不一样：
* 局部变量：位于栈内存中；
* 成员变量：位于堆内存中；
*
* 5.生命周期不一样：
* 局部变量：随着方法进展而诞生，随着方法出栈而消失；（定义在方法中，或者作为方法的参数）；
* 成员变量：随着对象的创建而诞生，随着对象被垃圾回收而消失；
*
*
*
* 面向对象三大特性之：封装；继承；多态；
* 封装：
* 1.方法就是一种封装；(调用方法，得到结果，不关注程序实现的功能的具体步骤)
* 案例：
* public class Demo02Method{
* public static void main(String[]args){
* int[] arrayInteger = {1,2,3,4,5};
* int max = getMax(arrayInteger);
* }
* public static getMax(int[] array){
* int max = array[0];
* ...............
* return max ;
* }
* }
* 2.关键字private也是一种封装；
* 一旦使用private（权限修饰符）修饰，那么本类当中可以继续访问；但是超出了本类范围不可访问；
* 定义Getter/Setter方法：
* getXxx()：无参数，有返回值（返回值类型和成员对应）
* setXxx()：有参数，无返回值(参数类型和成员变量对应)
*
* 对于基本类型当中的boolean类型
* Getter方法，写成isXxx()的类型
* Setter方法，写成setXxx()的类型
*
*
* this关键字：
* 当方法的局部变量和成员变量重名时，根据"就近原则"，优先使用局部变量；
* 如果需要访问本类中的成员变量，需要使用格式：
* this.成员变量名
* this定义在类的成员方法中--> 想调用这个成员方法 --> 就需要定义这个类的对象 --> 通过对象调用类的成员方法（this只能用在成员方法中的）
* 通过谁调用的方法，谁就是那个this --> 代表当前类的对象引用 -->所以this就是表示当前正在调用类的对象的地址
* 调用方法就必须使用类的对象
* 那么也就是说，this代表那个调用成员方法的类的对象
* this只能使用在成员方法中；
* 构造方法：
* 构造方法就是用来创建类的对象；
* 构造方法就是用来给类的对象的数据进行初始化；

* 格式：
* Public 类名称(参数类型参数名称){
* 方法体;
* }
* 注意事项：
* 1.构造方法的名称必须和类名必须完全一样，连大写小也要一样；
* 2.构造方法不要写返回值类型，连void都不写；
* 3.构造方法不能return一个具体返回值；
* 构造方法的调用是通过new来调用的；
* * new 构造方法名();
* 4.如果没有编写任何构造方法，那么编译器将会默认一个构无参构造方法，方法体什么事情都不做；
* 5.一旦编写了至少一个构造方法，那么编译器将不再默认构造方法；
* 6.构造方法也可以进行重载；
* 7.{
* 无参构造：①就是用来创建类的对象；
* 有（全）参构造：可以进行对象的数据初始化，但是由于无法访问对象的数据，
* 还得新增Getter方法，所以Getter和Setter方法都不省略；同时还有一个原因：可能改变对象中的数据，故Setter方法还得继续使用；
*
* }
* 所以一个标准的事物类包含{ --> 标准的类叫 Java Bean
* 1.成员变量：所有的成员变量都使用private关键字修饰；

* 2.构造方法{
* 无（空）参构造:创建类的对象
* 有（全）参构造:①创建类的对象 ②给对象的数据进行初始化
* }
* 3. {
* Setter方法
* Getter方法
* }
* }

方法的分类：
静态方法：
成员方法：
构造方法：new 动作调用，创建对象，给对象的数据进行初始化;

一、数组的定义和访问
* 数组的定义：-->一组数
* 是一种容器-->用来存放具有相同数据类型的多个变量的容器；
* 特点：
* 1.数组是一种引用数据类型；（除了四类八种类型外都是引用数据类型）
* {
* 1.整型值：{
* byte 1Byte=8bit -2^7~+2^7 -128~+127
* short 2Byte=16bit -2^15~+2^15-1 -32768~+32767
* int 4Byte=32bit -2^31~+2^31-1 ~21.47亿
* long 8Byte=64bit -2^63~+2^63-1 ~19位数值
* }
* 2.浮点型：{
* float 4Byte=32bit 但是由于float是采用科学计数法存储，省空间，实际取值范围大于8Byte的int类型
* double 8Byte=64bit
* }
* 3.字符型：char 2Byte=16bit
* 4.布尔类型 boolean 1Byte 取值范围 true ~ false
* }
* 
* 常见的引用数据类型：接口 interface
* 类 class -->String类型是引用数据类型
* 数组 array
* 2.数组当中的多个数据，数据类型必须统一；
* 3.数组的长度在程序运行期间不可改变；//array.length 就是数组的固有成员，长度需要在程序运行期间保持不变，固定长度
* 
* 格式：
* 数组的初始化：在内存中，创建一个数组，并且向其中赋予一些默认值；
* 1.动态初始化（指定长度）
* 数据类型 [] 数组名称=new 数据类型 [数组长度];
* 解析：
* 左侧数据类型：数组当中保存的统一的数据类型；
* 左侧的[]代表是一个数组；
* 左侧数组名称：数组的名称；-->就是变量名称，符合lowerCamelCase小驼峰的书写规范
* 右侧的new：代表创建数组的动作，开辟内存空间；（new是新增，创建之意，它会在堆Heap当中申请内存分配，开辟空间）
* 右侧的数据类型：必须和左边的数据类型保持一致；
* 右侧中括号中的长度：也就是数组可以存放的数据元素的个数；即数组的长度
* 
* 案例：double [] arrayB=new double [10];//数组名是变量名=lowerCamleCase;
* 
* String [] arrayStr=new String[5];
* 
* 2.静态初始化（指定内容）：在创建数组时，不直接指定数据的个数，而是直接指定存放的具体数据内容；
* 基本（标准）格式：
* 数据类型[] 数组名=new 数据类型[]{元素1，元素2.........}；
* 案例：int[] arrayInt=new int[] {1,2,3,4,5};
* String[] arrayStr=new String[] {"Hello","World"};
* 注意：虽然静态初始化没有直接指定数组的长度，但是数组的长度可以通过计算得到；所以数组的长度在程序的运行期间是不可变的；是确定的；
* 
* 省略（简化）格式：
* 数据类型[] 数组名={元素1，元素2，元素3............};
* 
* 注意事项：
* 1.静态初始化没有直接指定长度，但是仍然会自动推算得到长度；
* 2.静态初始化的标准格式可以拆分成两个步骤；
* int[] arrayB;//定义数组变量
* arrayB=new int[]{1,2,3,4};//给变量赋值
* 3.动态初始化也可以拆分成两个步骤；
* int[]arrayC;
* arrayC=new int[10];
* 4.静态初始化的省略格式不能拆分成两个步骤；（不带new不能拆分）
* int[]arrayD;
* arrayD={1,2,3};//错的
* 5.使用建议：确认个数（长度）但是不确定内容-->动态初始化；
* 确定内容 -->静态初始化；//静态赋值的方式其数组的长度也是确定的，不可变的。长度会计算得到一个确认的唯一值；
* 
* 数据元素的访问：
* 直接打印数组名称时，得到的是数组对应的：内存地址哈希值；（地址值）
* 引用数据类型直接打印变量名称时打印的是16进制的哈希值-->逻辑地址值
* 
* 访问数组元素的格式：数组名称[索引值];
* String[] arrayStr={"Hello","World"};
* String str=arrayStr[0]; //变量的值传递
* 
* 注意：index索引值从0开始到array.length-1结束；[0,array.length)
* 数组元素的值：
* 打印调用；
* 赋值调用
* 
* 动态初始化的元素访问：
* 动态初始化数组时，其中的元素将会有一个默认值；
* 整型值：默认0；
* 浮点型：默认0.0；
* 字符型:"\u0000";
* 布尔类型：false;
* 引用数据类型：null;空常量，不能直接打印； //System.out.println(null);
* 
* 注意事项：数组的静态初始化其实数组也有默认值，只不过是立刻被替换了；
* index , 号 -->个-1；
* 其实数组中的元素就是对应类型的变量；
* 
* 
* java中的内存分配：
* 自动内存管理；
* 动态内存分配；
* 
* java的虚拟机即JVM需要对内存进行管理和划分，划分为5大部分：
* 1.栈（Stack）：
* 存放的都是局部变量；
 局部变量：方法的参数，或者是方法{}内部的变量；（1.方法的参数 2.方法中定义的变量都称之为局部变量，局部变量的特征是有作用域（作用域：就是变量所属的那对大括号{}））
* 方法的执行需要进栈；
 方法的执行都是在栈内存中进行的；
* 
* 2.堆（Heap）：凡是new出来的东西，都在堆当中；
* new出来的东西一般叫做实体-->对象-->{
* 1.每个对象都有一个地址值；
* 2.对象的数据都有默认值；
* }
* 
* 3.方法区(Method Area)：存储.class相关信息（编译后的字节码文件），包含方法的信息；
* 程序的入口是：main方法，main方法是主方法；
* 
* 4.本地方法栈（Native Method Stack）:与操作系统相关。
* 
* 5.寄存器(Pc Register)：与cpu相关；
* 
* 
* 一个数组的内存图：
* 见图：
* 方法区：Method Area .class文件-->main方法进栈：在栈stack内存中开辟空间；
* -->new 数据类型[数组的长度]：在Heap堆中申请内存分配，开辟空间
* -->每个对象都有一个地址值，对象的数据都有默认值
* -->堆Heap中的对象的地址值赋值给栈Stack中的数组变量（完成关联）
* -->给数组元素赋值：通过地址值和索引组合的方式找到Heap堆中的数据进行替换
* 存储设备：
* 1.硬盘
* 2.内存
* 3.缓冲
* 
* java的GC回收机制，栈内存使用完毕，立刻被回收，生命周期很短；
* int[] arrayInteger;//其实就是一个局部变量；
* arrayInteger=new int[10];//new在堆内存中申请内存分配，开辟空间；
* 堆内存中的对象都有一个地址值；
* 对象中的数据都有一个默认值；
* 整型值：默认0；
* 浮点型：默认0.0；
* 字符型:"\u0000";
* 布尔类型：false;
* 引用数据类型：null;空常量，不能直接打印
* 
* 
* 
* 两个数组的内存图：
* 完全和一个数组的内存图一样，就是copy一份，互不影响；
* 
* 
* 两个数组指向同一个数组：两个引用指向同一个堆内存中的数组；
* 注意：任意一个引用改变了数据，另外一个也会访问到更改后的数据；
* 
* 
* 数组访问时可能出现的2个异常，注意事项：
索引也叫下标、角标
* 1.数组索引[0,array.length-1] //ArrayIndexOutOfBoundsException:数组索引越界(超出界限)异常 //注意，索引越界异常ArrayIndexOutOfBoundsException 编译不会报错，但是运行会报错
* 2.空指针异常；
* 所有的引用数据类型的变量，都可以赋值为一个null值，表示地址值是null；
* 注意数组必须进行new初始化才能使用其中的元素；
* 只是给数组变量赋值一个null，那么报错：NullPointerException;-->空指针异常；
* int[] arrayInteger;
* arrayInteger = null;//不会报错，但是实际的地址值是null
* 
* 
* 获取数组长度的方法：
* 数组名称.length;
* array.length; //数组的长度在程序运行期间，不可发生变化；
* 数组指的是-->new 出来的东西；长度不可变；array.length;不是方法，是固有成员；
* int length = arrayC.length;//arrayC.length.var可以快捷的赋值调用
* GC garbage collection 垃圾回收机制：
* 堆内存空间，空闲时回收
* 栈内存空间，立刻回收
* 
* 数组元素的遍历：
* 就是说对数组中的每一个元素进行逐一处理，默认处理方式为打印；
* //for循环遍历数组元素：对数组元素进行逐一处理；
* //快捷方式：数组名.fori;--> enter enter ;
* int[] arrayInteger = new int[]{1,2,3,4,5,6,7,8};
* for (int i = 0; i < arrayInteger.length; i++) {
* System.out.print(arrayInteger[i]+"\t");
* }
*
* 注意：shift+f6;全员替换；
* C:\Users\Administrator\.IntelliJIdea2018.2\config 是Intellij Idea的配置信息；
*
* //比较时需要从被比较的数据拉出来任意一个为比较基数，一般取array[0];
* {
* System.out.println("请输入学生的个数：");
* Scanner sc = new Scanner(System.in);
* //学生的个数
* int count = sc.nextInt();
* //定义一个数组的，长度为count
* int[] arrayStudent = new int[count];
* //遍历赋值
* for (int i = 0; i < count; i++) {
* System.out.println("学生的成绩");
* int score = sc.nextInt();
* arrayStudent[i] = score;
* }
* //遍历输出
* for (int i = 0; i < arrayStudent.length; i++) {
* System.out.print(i+":"+arrayStudent[i]+"\t");
* }
* System.out.println();
* //求min
* int min = arrayStudent[0];
* for (int i = 1; i < arrayStudent.length; i++) {
* //比最小的还小，我就留下这个相对小的值；
* if(arrayStudent[i] < min){
* min = arrayStudent[i];
* }
* }
* System.out.println("min:"+min);
* }
*
* 数组元素的反转：其实就是对称位置的元素交换；
* //数组元素的反转
* int[] arrayReverse = new int[]{1,2,3,4,5,6,7,8,9,10};
* for (int i = 0,j=arrayReverse.length-1; i < j; i++,j--) {
* //利用temp中间量进行数据交换，首尾相接的书写格式
* // int temp = a;
* // a = b;
* // b= temp;
* int temp=arrayReverse[i];
* arrayReverse[i]=arrayReverse[j];
* arrayReverse[j]=temp;
* }

public class ArrayReverse {
public static void main(String[] args) {
 //静态初始化数组元素
 int[] arrayInteger = {1, 2, 3, 4, 5};
 //调用反转方法01
 arrayReverse01(arrayInteger);
 //调用反转方法02
 arrayReverse02(arrayInteger);
}

/**
 * 实现反转的方法01
 */
private static void arrayReverse01(int[] arrayInteger) {
 //反转的本质是对称位置的元素交换
 //使用循环交换，判断条件语句的-->程序得以继续的条件是：min < max //偶数（even number）min < max 奇数(odd Number) min <= max
 //定义对称位置的起始索引变量
 for (int min = 0, max = arrayInteger.length - 1; min < max; min++, max--) {
 //定义中间交换变量temp,首尾相接的方式，实现对称位置的数据交换
 int temp = arrayInteger[min];
 arrayInteger[min] = arrayInteger[max];
 arrayInteger[max] = temp;
 }
 //实现反转后的数组的遍历输出
 for (int i = 0; i < arrayInteger.length; i++) {
 System.out.print(arrayInteger[i] + "\t");
 }
 //实现换行
 System.out.println();
}

/**
 * 实现反转的方法02
 */

private static void arrayReverse02(int[] arrayInteger) {
 //实现反转的方式2,思想-->对称位置的索引相加=array.length-1;
 int len = arrayInteger.length / 2;
 // 这里取 i < arrayInteger / 2; 如果偶数个 0 1 2 3 如果奇数个 0 1 2 3 4
 for (int i = 0; i < len; i++) {
 //利用temp中间变量实现交换数据
 int temp = arrayInteger[i];
 arrayInteger[i] = arrayInteger[arrayInteger.length-1-i];
 arrayInteger[arrayInteger.length-1-i] = temp;
 }
 //遍历输出
 for (int i = 0; i < arrayInteger.length; i++) {
 System.out.print(arrayInteger[i]+"\t");
 }
 //实现换行
 System.out.println();
}
}

*
*数组作为方法参数（实际参数）-->传递地址值；任何数据类型都可以作为方法的参数：基本/引用
*数组可以作为方法的参数：
* 调用方法时，传递的实际上是地址值；

import java.util.Scanner;
/**
* 数组作为方法的参数，或者数组作为方法的返回值，其实本质上传递的是数组的地址值，或者返回的是地址值
* 案例：输入学生的成绩，返回总成绩，输入的学生的成绩个数，平均值，小于平均值的人数个数
*/
public class ArrayParameter {
public static void main(String[] args) {
 //键入并接收学生的成绩
 Scanner sc = new Scanner(System.in);
 //明确数组的长度，即学生个数
 System.out.println("请输入学生的个数:");
 int count = sc.nextInt();
 //定义数组接收用户的成绩,动态初始化，长度为count
 int[] arrayScore = new int[count];
 //遍历数组，并把数据插入到数组中
 for (int i = 0; i < arrayScore.length; i++) {
 System.out.println("请输入第" + (i + 1) + "个学生的成绩：");
 int score = sc.nextInt();
 //成绩赋值给数组元素；
 arrayScore[i] = score;
 }
 //数组作为方法的参数(实际参数)，并且数组作为方法的返回值，实际上传入的是地址值，返回的也是地址值
 double[] avgSum = getAvgSum(arrayScore);
 for (int i = 0; i < avgSum.length; i++) {
 System.out.print(avgSum[i] + "\t");
 }
}

/**
 * @param arrayScore
 * @return
 * @description 定义一个方法，实现数组作为参数输入，返回总成绩，输入的学生的成绩个数，平均值，小于平均值的人数个数的数组；
 */
private static double[] getAvgSum(int[] arrayScore) {
 //遍历方法调用者传入的实际参数-->数组：传入的是地址值;-->引用数据类型传入的都是地址值\
 //定义求和变量，累加变量，平均值变量
 int sum = 0;
 int count = 0;
 double average;
 for (int i = 0; i < arrayScore.length; i++) {
 //实现成绩的累加
 sum += arrayScore[i];
 count++;
 }
 //double类型的average更为精确
 average = sum / (double) count;
 //遍历数组，开始求取小于平均值的学生的个数
 int countStu = 0;
 for (int i = 0; i < arrayScore.length; i++) {
 if (arrayScore[i] < average) {
 countStu++;
 }
 }
 //定义一个数组，用来存储具有相同数据类型的多个元素
 double[] arrayAvgSum = {sum, count, average, countStu};
 return arrayAvgSum;
}
}

*
* 方法的返回值是不是可以是地址值？
* 一个方法可以有多个参数[0-n]
* 但是只能有0或1个返回值
*
*数组不仅可以作为方法的参数，还可以作为方法的返回值，实际上传入的或者返回的都是引用数据类型的地址值：
*注：当实际参数为基本数据类型，形式参数的改变不会影响实际参数; 当实际参数为引用数据类型时，那么形式参数的改变会直接影响实际参数;、
* 如果方法的参数为基本数据类型，那么传递的是数据值; 如果方法的参数为引用数据类型时，那么传递的是地址值;

方法的三要素：{
1. 返回值类型
2. 方法名称
3. 参数列表{
1. 参数的个数不同;
2. 参数的数据类型不同;
3. 参数的多类型顺序不同;
 }
}

小堂姐姐 · 小堂姐姐

帐号		自动登录	找回密码
密码			加入黑马

[学习交流] java基础学习交流

1 个回复