Java基础
Java基础
1.Java概念
1.1.Java是什么？
Java，由Sun Microsystems公司于1995年5月推出，它是一种可以编写跨平台应用软件、完全面向对象的程序设计语言。
1.2.面向对象是什么？它的基本特征是什么？
面向对象：面向对象是已对象为基础，完成各种操作主要强调对象、结果。是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
面向对象3大基本特征：封装、继承、多态。
1.3.java的三大版本以及它们的区别？
1.JavaSE（标准版，定位在个人计算机的应用）
2.JavaEE（企业版，定位在服务器的应用。市场上的主流）
3.JavaME（微型办，定位在消费性电子产品的应用上）
1.4.JDK是什么？由几部分组成？每一部分是什么？
1.JDK是 Java 语言的软件开发工具包。
2.组成及是什么：
- javac – 编译器，将源程序转成字节码
- jar – 打包工具，将相关的类文件打包成一个文件
- javadoc – 文档生成器，从源码注释中提取文档
- jdb – debugger，查错工具
- java – 运行编译后的java程序（.class后缀的）
- appletviewer：小程序浏览器，一种执行HTML文件上的Java小程序的Java浏览器。
- Javah：产生可以调用Java过程的C过程，或建立能被Java程序调用的C过程的头文件。
- Javap：Java反汇编器，显示编译类文件中的可访问功能和数据，同时显示字节代码含义。
- Jconsole: Java进行系统调试和监控的工具
1.5.JDK安装和环境变量配置？
配置环境变量；
1、桌面计算机图标右键属性
2、高级系统设置，环境变量，
3、配置系统变量
1)、新建
变量名： JAVA_HOME (根目录)
变量值： D:\software\jdk1.8； --- 根据自己电脑存放位置决定
2)、新建
变量名： CLASSPATH
变量值：(英文点).
3)、编辑
变量名： path
变量值： D:\software\jdk1.8\bin; -- 根据自己电脑存放位置上边文件的 bin目录
配置成功后一路确定
验证环境变量成功；
键盘上win建+r 输入 java -version 确定 {在java和-version中间(输入空格)}
1.6.java程序的执行原理？
java程序执行过程分为两步，下图为流程示意图
-
第一步：将java源码(.java文件)通过编译器(javac.exe)编译成JVM文件(.class文件)
-
第二步：将JVM文件通过java.exe执行，输出结果
例如：
//测试java运行过程 public class JavaRun { public static void main(String[] args){ System.out.println("Hello,world"); } }1.用notepad++手写一个java程序，并保存为JavaRun.java。
2.用javac.exe将刚保存的JavaRun.java文件编译成JavaRun.class文件
3.java.exe执行JavaRun.class文件，输出结果
1.7.java语言的特点
特点一：面向对象
两个基本概念：类、对象
三大特性：封装、继承、多态
特点二：健壮性
吸收了C/C++语言的优点，但去掉了其影响程序健壮性的部分，提供了一个相对安全的内 存管理和访问机制
特点三：跨平台性
跨平台性：通过Java语言编写的应用程序在不同的系统平台上都可以运行。
原理：只要在需要运行 java 应用程序的操作系统上，先安装一个Java虚拟机 即可。由JVM来负责Java程序在该系统中的运行。
Java语言的特点：跨平台性
特点四：异常处理机制
特点五：自动垃圾回收机制
特点六：多线程
2.数据类型
2.1.什么是注释？注释的作用是什么？注释的分类以及具体的表现形式？
注释就是对代码的解释和说明，其目的是让人们能够更加轻松地了解代码。
Java中代码的注释有三种：
// 注释一行 /* ...... */ 注释若干行 /** ...... */ 注释若干行 package com.click369; /** * 第一个java程序 * 若干行注释 */ public class hello { public static void main(String[] args) { //一行注释 /* public String sayHello(){ return "hello,Springboot"; } 若干行注释 */ System.out.println("你好！！"); } }2.2标识符是什么？标识符的具体规则？
ava语言中，对于变量，常量，函数，语句块也有名字，我们统统称之为Java标识符.标识符是用来给类、对象、方法、变量、接口和自定义数据类型命名的。
1.类和接口名。每个字的首字母大写，含有大小写。例如，MyClass，HelloWorld，Time等。
2.方法名。首字符小写，其余的首字母大写，含大小写。尽量少用下划线。例如，myName，setTime等。这种命名方法叫做驼峰式命名。
3.常量名。基本数据类型的常量名使用全部大写字母，字与字之间用下划线分隔。对象常量可大小混写。例如，SIZE_NAME。
4.变量名。可大小写混写，首字符小写，字间分隔符用字的首字母大写。不用下划线，少用美元符号。给变量命名是尽量做到见名知义。
2.3.什么是关键字？Java中常用的关键字？
Java关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数。
2.4.什么是变量？变量的作用？变量的组成？
变量–在程序运行的时候随时可能发生变化的数据就是变量。
变量的作用:保存具体的数据值，限制了数据值在内存中的位置和大小
java中变量的组成部分：
1.数据类型—决定内存空间
2.变量名称—自定义的，只要符合标识符的规则
3.初始值—默认值
4.作用域—有效范围
2.5.Java中的基本数据类型有几种？如何表示，取值范围，注意事项？
java中的基本数据类型分为为两大类分别是：
内置数据类型
Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。
public class Test { static boolean bool; static byte by; static char ch; static double d; static float f; static int i; static long l; static short sh; static String str; public static void main(String[] args) { System.out.println("Bool :" + bool); System.out.println("Byte :" + by); System.out.println("Character:" + ch); System.out.println("Double :" + d); System.out.println("Float :" + f); System.out.println("Integer :" + i); System.out.println("Long :" + l); System.out.println("Short :" + sh); System.out.println("String :" + str); } }输出结果
引用数据类型
- 对象、数组都是引用数据类型。
- 所有引用类型的默认值都是null。
2.6.基本数据类型之间的转换？注意事项？
- 基本数据类型从小到大的顺序：
- byte→short→int→long→float→double
- char→int
- boolean不参与转换。
- 基本数据类型有两种转换方式：自动类型转换、强制类型转换
自动类型转换：小类型到大类型的转换小类型可以自己转换到大类型，不需任何其他操作。
强制类型转换：大类型到小类型大类型转换小类型，需在变量前添加要转换成的数据类型。
long l = 1;
int i = (int)l;
基本数据类型转换需遵守的规则之一：整数直接量可以直接赋值给byte、short、char，但不能超取值范围。
基本数据类型转换需遵守的规则之二：byte、short、char型数据参与运算时，先一律转换为int再运算。
注意：
整型默认是int类型；小数类型默认是double；char可当成一种特殊的整型。boolean类型不能转换成其他任何数据类型。
2.7.什么是数组？如何定义？如何创建？如何赋值？如何取值？有那些属性
同一数据类型的一组数据按照顺序排列的复合数据类型—数组。
- 同一数据类型 【进入数组的数据的类型必须相同】
- 按照顺序排列
- 复合数据类型
格式： 1. 数据类型 数组名称[];
2.数据类型 []数组名称;
例如：
//定义一个数组
//1. 数据类型 数组名称[];
int arr1[];
//2.数据类型 []数组名称;
char []arr2;
- 创建数据 【为数组开辟保存数据的内存空间】
格式: 数组名称 = new 数据类型[空间大小];
例如：
arr1=new int[4];
arr2=new char[5];
可以将定义数组与创建数组合并成一句话表示：
- 数据类型 数组名称[] = new 数据类型[空间大小];
2.数据类型 []数组名称 = new 数据类型[空间大小];
例如：
double arr3[]=new double[4];
byte []arr4=new byte[5];
-
数组赋值
-
逐个赋值 【需要数组下标，从0开始】
格式：数组名称[下标] = 数据值/变量；
超过数组空间大小以后会出错“java.lang.ArrayIndexOutOfBoundsException”
例如：
arr2[0]='h';
arr2[1]='e';
arr2[2]='l';
arr2[3]='l';
arr2[4]='o';
//超过数组空间大小以后会出错
//java.lang.ArrayIndexOutOfBoundsException
//arr2[5]='w';
- 直接赋值【就是在创建数组的时候赋值】
char chararray[]={'h','e','l','l','o'};
char []chararray={'h','e','l','l','o'};
char []chararray=new char[]{'h','e','l','l','o'};
char chararray[]={'h','e','l','l','o'};
char chararray[]=new char[]{'h','e','l','l','o'};
char []chararray=new char[]{'h','e','l','l','o'};
//char []chararray=new char[5]{'h','e','l','l','o'}; //错误
6.从数组中取值
格式： 数组名称[下标]
System.out.println("取值==="+intarray[3]);
7.遍历数组【循环语句】
总结：1.”[]”数组的标志
2.当数组名称后面有一个“[]”,这个就是一维数组，当数组名称后面有两个“[]”,这个就是二维数组，超过两个“[]”，统一叫多维数组。
- 以上都是一维数组内容。下面简单介绍二维数组构造。
- 定义二维数组 ： 数据类型 数组名称[][]/数据类型 [][]数组名称;
- 创建二维数组 : 数组名称=new 数据类型空间大小
2.8.认识Arrays类【数组的帮助类】？
Arrays提供了一组操作array的静态方法
public static void printBaseArray(){
int[] ar = new int[10];
for (int i=0; i < ar.length; i++) {
ar[i] = (1000 - (300 + i));
}
System.out.println("打印基本类型数组:"+Arrays.toString(ar));
}
执行结果
打印基本类型数组:[700, 699, 698, 697, 696, 695, 694, 693, 692, 691]
对象类型数组打印
public static void printObjectArray(){
Random random = new Random();
Cell[] cells = new Cell[10];
for(int i=0;i<10;i++){
cells[i] = new Cell(random.nextInt(50),random.nextInt(50));
}
System.out.println("打印对象类型数组:"+Arrays.toString(cells));
}
public class Cell {
private int x;
private int y;
public Cell(int x,int y){
this.x = x;
this.y = y;
}
public String toString(){
return "x="+x+",y="+y;
}
}
执行结果：
打印对象类型数组:[x=24,y=38, x=0,y=9, x=5,y=1, x=36,y=9, x=36,y=38, x=47,y=2, x=45,y=32, x=9,y=46, x=36,y=5, x=17,y=3]
2.9基本数据类型与复合数据类型的区别？
1、基本数据bai类型由于在内存中的一个du地址存放的是这些变量的值 所以调用函数，函数里的形参 ，就是复制这些变量的值 以后对形参值的变化 不会影响到原来变量的值；
2、引用数据类型由于在内存中是引用他的一个内存地址而不是具体的值，所以 调用函数， 函数里的形参， 就是复制这些变量的值的地址 ，当对形参的值进行修改的时候 就等于是对 这些变量的值 进行修改， 所以会影响到原来变量的值。
2.10.Scanner类的用法？
用法1.
public class Text {
public static void main(String []args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入一个字符串(中间能加空格或符号)");
String a = input.nextLine();
System.out.println("请输入一个字符串(中间不能加空格或符号)");
String b = input.next();
System.out.println("请输入一个整数");
int c;
c = input.nextInt();
System.out.println("请输入一个double类型的小数");
double d = input.nextDouble();
System.out.println("请输入一个float类型的小数");
float f = input.nextFloat();
System.out.println("按顺序输出abcdf的值：");
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
System.out.println(f);
}
}
请输入一个字符串(中间能加空格或符号)
我爱祖国！
请输入一个字符串(中间不能加空格或符号)
ILoveChina
请输入一个整数
520
请输入一个double类型的小数
12.26e3
请输入一个float类型的小数
3.1415926
按顺序输出abcdf的值：
我爱祖国！
ILoveChina
520
12260.0
3.1415925
用法2.
public class inputInformation {
public static void main(String args[]) {
Scanner scan = new Scanner(System.in); //构造Scanner类的对象scan，接收从控制台输入的信息
System.out.println("请输入你的姓名");
String name = scan.nextLine();//接收一个字符串，可以加除Enter以为的所有符号，包括空格和Tab
System.out.println("请输入你的ID");
String ID ;
while(scan.hasNextLine()) {// hasNextLine()方法判断当前是否有输入，当键盘有输入后执行循环
if(scan.hasNextInt()) {// 判断输入的值是否为整数类型，当为整数类型时执行循环
ID = scan.nextLine();
System.out.println("你输入的姓名为："+name);
System.out.println("你输入的ID为："+ID);
break;
}else {
System.out.println("请输入数字哦！");
ID = scan.nextLine();
continue;
}
}
}
}
请输入你的姓名
西瓜西瓜
请输入你的ID
123165
请输入数字哦！
764323221
3.表达式和语句
3.1.常见的运算符和表达式
1.运算符的运算级别分为很多层，第一层是()，括号的运算级别最高。
第二层是+，——，*，/，加，减，乘，除
第三层是==，等于号。
第四层是&&，||，或 与 且 &&比||高一层如果它们同时存在首先运行的是&&。
这里有注意：容易把 加，减，乘，除 和 运算符弄乱,比如 System.out.println("814-6"); 这个到底是运算哪一个先呢？第二层是加，减，乘，除 ，所以首先运行的是加，减，乘，除。
2.条件运算符 ？：也称为三元表达式。
out.println(条件？真：假)//如果条件为真则返回真否则返回假。
3.2.常见语
-
1.判断语句【if switch】
switch (n) { case 0: cc = 1; break; case 1: cc = 2; break; case 2: cc = 3; break; default: cc = null; break; } console.log(cc); -
2.循环【for while do{}while()】
//例子 //在控制台输出10次“helloworld” for（int i=0；i<10; i++）{ System.out.println("helloworld"); } //练习1，在控制台输出数据1-10 //练习2，在控制台输出数据10-1 for(int i=1;i<=10;i++){ System.out.println("i="+i); } for(int i=10;i>=1;i--){ System.out.println("i="+i); }//例子 //在控制台输出1-10 int x=1; while(x<=10){ System.out.println("x="+x); x++; } //练习一：求和思想,求1-100之和 int sum=0; int i=1; while(i<=100){ sum+=i; //sum=sum+i; i++; //让变量i自增 } System.out.println("sum="+sum); } //练习二：统计思想,统计水仙花个数 int count = 0; //计数器 int i =100; while(i<=999){ int ge = i%10; int shi = i/10%10; int bai = i/10/10%10; if(i==ge*ge*ge+shi*shi*shi+bai*bai*bai){ count++; } i++; } System.out.println("count"+count); } -
2.2 while 与 do{}while()
do-while与while-do区别为：跳出循bai环不同du、执行次数不同、优先操作不同。
一、跳出循环不同
1、do-while：do-while不可以通过break在循环过zhi程中跳出。
2、while-do：while-do可以通过break在循环过程中跳出。
二、执行次数不同
1、do-while：do-while至少会执行一次循环体。
2、while-do：while-do可能会出现一次都不执行循环体的情况。
三、优先操作不同
1、do-while：do-while优先执行循环体，再判断执行条件是否符合要求。
2、while-do：while-do优先判断执行条件是否符合要求，再执行循环体。
-
3.break与 continue
1.break
用break语句可以使流程跳bai出switch语句体，也可以用dubreak语句在循环结构终止本层循环体，从而提前zhi结束本层循环。
使用说明：dao
（1）只能在循环体内和switch语句体内使用break；
（2）当break出现在循环体中的switch语句体内时，起作用只是跳出该switch语句体，并不能终止循环体的执行。若想强行终止循环体的执行，可以在循环体中，但并不在switch语句中设置break语句，满足某种条件则跳出本层循环体。
2.continue
continue语句的作用是跳过本次循环体中余下尚未执行的语句，立即进行下一次的循环条件判定，可以理解为仅结束本次循环。
注意：continue语句并没有使整个循环终止。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vGZfIgrK-1595507651222)(C:\Users\18373\Desktop\Java基础\img\循环while与dowhile.png)]
-
4.return
return 语句的作用是从当前函数退出，并从那个函数返回一个值。
用 return 语句来终止一个函数的执行，并返回 expression 的值。如果 expression 被省略， 或在函数内没有 return 语句被执行，则把值 undefined 赋给调用当前函数的表达式。
4.类和对象
4.1.类是什么？
1.性质或特征相同或相似的事物综合体就是类。【人类，汽车类…动物类】
2.类–类型–java数据类型—java中的复合数据类型–自己定义的复合数据类型
2.1 基本数据类型 【byte,short,char,int long,float,double,boolean】
2.2 复合数据类型
答：通过java语言描述一组性质或特征相同或相似事物的自己定义的复合数据类型。。
4.2.类是如何编写的？
Public class Stack{
private Vector items;
publicd Stack(){
items = new Vector(10);
}
public Object push(Object item){
items.addElement(item);
returen item;
}
public synchronized Object pop(){
int len = items.size();
Object obj = null;
if(len == 0)
throw new EmptStackException();
obj = items.elementAt(len - 1);
items.removeElementAt(len - 1);
return obj;
}
public boolean isEmpty(){
if(items.size() == 0)
return true;
else
return false;
}
}
类中可以有变量和方法
- 访问限制修饰符 class 类名{}
通过class关键字来创建一个类。
格式：访问限制修饰符 class 类名{}
//创建一个学生类
public class Student{
}
class Student{
}
-
- 访问限制修饰符—public 缺省的public----[公共的] 所有包都可以访问缺省的–[友好的] 同一个包中可以访问。
-
- class—创建类的关键字【类的标志】
-
- 类名–合法的标识符【每一个的单词的首字母大写】
-
- {}----类体
4.3.类中可以编写什么？
- 类中可以编写变量和方法。
- 用变量来描述事物的基本特征【属性】，用方法来描述事物的基本行为【功能】。
4.4.类中的变量的分类以及特征？成员变量的隐藏？静态成员变量与实例变量的区别？
1.变量书写在类体中。变量–保存数据
- 数据类型【基本数据类型/复合数据类型】
- 变量名称【合法的修饰符，全字母小写】
- 初始值
- 作用域【有效范围】
2.变量的分类
- 成员变量【全局变量】—类中除过方法以外的地方【在类体，但没有在方法中】。
- 局部变量—类中的方法里面和方法的参数。
package com.click369.test1;
public class TestClass1 {
//类体中可以有变量和方法
//定义一个变量
/*
* 1.数据类型
* 2.变量名称
* 3.初始值
* 4.作用域【全局/局部】
* 全局/成员--整个类中通用【整个类中的任何一个方法中都可以调用】
* 局部-----只能在本方法中使用
*/
//出现在类体中，但不在方法中----成员变量【全局变量】
int test1=1001;
//类中的方法
public void my1(){
//出现在类体中,在方法中----局部变量
double dou=12.5;
}
//char ch变量出现在方法的参数位置----局部变量
public void my2(char ch){
}
}
成员变量【全局变量】的特征
- 类中除过方法以外的地方。
- 可以没有初始值，系统会自动赋予这个全局变量一个默认的初始值。
- 需要访问限制修饰符
- 可以在本类中的任何一个方法中被使用，且不受访问限制修饰符的影响。
局部变量的特征
- 类中的方法里面和方法的参数。
- 局部变量一定要有初始值。
- 不能有访问限制修饰符
- 只能在定义该局部变量的方法中使用，超出本方法就错误
package com.click369.test1;
public class TestClass2 {
//test1是一个全局变量
//1.类中除过方法以外的地方。
//2.可以没有初始值，系统会自动赋予这个全局变量一个默认的初始值。
//3.需要访问限制修饰符
//4.可以在本类中的任何一个方法中被使用，且不受访问限制修饰符的影响。
public int test1=1001;
public void my1(){
//dou是一个局部变量
//1.类中的方法里面和方法的参数。
//2.局部变量一定要有初始值,否则在调用的时候就会出错
//3.不能有访问限制修饰符
//4.只能在定义该局部变量的方法中使用，超出本方法就错误
double dou=12.5;
System.out.println(test1);
System.out.println(dou);
}
public void my2(){
System.out.println(test1);
//System.out.println(dou);
}
}
-
成员变量的隐藏
类中的某一个成员变量的名称与某一个方法中的局部变量的名称相同，那么类中的成员变量的数据值被局部变量覆盖隐藏。
package com.click369.test1; public class TestClass3 { //成员变量 public int test1=1001; public void my1(){ //局部变量 char test1='A'; //成员变量的隐藏 //在同一个类中，局部变量的名称与某一个成员变量的名称相同 //实例上是这个局部变量将成员变量的值覆盖 System.out.println(test1); //A //如果需要强制性使用被局部变量影藏的这个成员变量的数据值 //那么就需要给这个变量前面使用“this.”, //就可以使用被局部变量影藏的这个成员变量的数据值 System.out.println(this.test1); //1001 } }static关键字修饰变量【成员变量】
成员变量【全局变量】— 类中除过方法以外的地方。
根据是否有static关键字修饰，将成员变量划分为2类：
-
有static关键字修饰的成员变量-----静态成员变量【类变量】；
-
没有static关键字修饰的成员变量—实例成员变量【实例变量】；
-
package com.click369.test1;
public class TestClass4 {
//static -- 关键字【静态的】
//可以修饰成员变量，也可以修饰方法，不能修饰局部变量
//被static关键字修饰的成员变量叫静态成员变量【类变量】
public static int test1=1001;
//没有使用static关键字修饰的成员变量叫【实例变量】
public char test2='A';
//无论是静态成员变量【类变量】还是【实例变量】，他们都是成员变量【全局变量】
//因此他们都符合成员变量【全局变量】的基本特征
//1.类中除过方法以外的地方。
//2.可以没有初始值，系统会自动赋予这个全局变量一个默认的初始值。
//3.需要访问限制修饰符
//4.可以在本类中的任何一个方法中被使用，且不受访问限制修饰符的影响。
//【类变量】与【实例变量】的区别？
//1.语法定义上：类变量有static,实例变量没有static
//2.调用方式上：类变量可以使用对象调用，也可以使用类名调用, 实例变量只能通过对象调用
//3.内存配置上：类变量是在程序运行之前分配内存空间，实例变量是在程序运行时分配内存空间
public void my1(){
//局部变量
//static char test2='A'; //错误
char test3='A';
System.out.println(test1);
}
}
package com.click369.test1;
public class TestMain {
public static void main(String[] args) {
// TODO Auto-generated method stub
TestClass4 t4=new TestClass4();
//2.调用方式：类变量可以使用对象调用，也可以使用类名调用, 实例变量只能通过对象调用
//System.out.println(t4.test1);//对象调用
//System.out.println(TestClass4.test1);//类名调用
System.out.println(t4.test2);//对象调用
//System.out.println(TestClass4.test2);//对象调用
}
}
【类变量】与【实例变量】的区别？
- 语法定义上：类变量有static,实例变量没有static
- 调用方式上：类变量可以使用对象调用，也可以使用类名调用, 实例变量只能通过对象调用
- 内存配置上：类变量是在程序运行之前分配内存空间，实例变量是在程序运行时分配内存空间
4.5.类中的方法以及表现形式和特征？方法的重载？
用来描述具有共同性质的一组事物的基本行为。
普通方法【实例方法】基本格式：
访问限制修饰符 方法的返回值类型 方法的名称(方法参数列表){
需要实现的基本行为
}
访问限制修饰符—public 缺省的
方法的返回值类型—方法执行成功以后的结果的数据类型
--有结果，方法的返回值类型就是结果类型【基本类型，复合数据类型】，方法体的最后一句话是return xxx；语句
–没有结果，使用void表示
方法的名称----合法的标识符【首字母小写，从第二个单词开始首字母大写】
test testHello testHelloWorld
方法参数列表—接收方法以外的数据进入本方法【请人帮忙】
—可以一个参数都没有（）。
—可以有一个/多个（变量）/(int num1,double test1,String test)
{}—方法体
package com.click369.method1;
public class TestMethod1 {
/*
访问限制修饰符 方法的返回值类型 方法的名称(方法参数列表){
需要实现的基本行为
}
*/
public void test1(){
System.out.println("public修饰的没有返回值，没有参数，名称是test1的方法");
}
void test2(){
System.out.println("缺省修饰符修饰的没有返回值，没有参数，名称是test2的方法");
}
public int test3(){
System.out.println("public修饰的返回值为int，没有参数，名称是test3的方法");
return 100;
}
String test4(){
System.out.println("缺省修饰符修饰的返回值为String，没有参数，名称是test4的方法");
return "100";
}
public int test5(int num){
System.out.println("public修饰的返回值为int，有一个int型参数，名称是test5的方法");
return 100+num;
}
double test6(int num,double test){
System.out.println("缺省修饰符修饰的返回值为double，有两个参数，名称是test6的方法");
return num+test;
}
}
静态方法【类方法】基本格式：
访问限制修饰符 static 方法的返回值类型 方法的名称(方法参数列表){
需要实现的基本行为
}
package com.click369.method1;
public class TestMethod2 {
/*
访问限制修饰符 static 方法的返回值类型 方法的名称(方法参数列表){
需要实现的基本行为
}
*/
public static void test1(){
System.out.println("public修饰的没有返回值，没有参数，名称是test1的静态方法");
}
static void test2(){
System.out.println("缺省修饰符修饰的没有返回值，没有参数，名称是test2的静态方法");
}
public static int test3(){
System.out.println("public修饰的返回值为int，没有参数，名称是test3的静态方法");
return 100;
}
static String test4(){
System.out.println("缺省修饰符修饰的返回值为String，没有参数，名称是test4的静态方法");
return "100";
}
public static int test5(int num){
System.out.println("public修饰的返回值为int，有一个int型参数，名称是test5的静态方法");
return 100+num;
}
static double test6(int num,double test){
System.out.println("缺省修饰符修饰的返回值为double，有两个参数，名称是test6的静态方法");
return num+test;
}
}
构造方法：
- 没有方法返回值类型部分
- 法的名称与类名称相同
访问限制修饰符 类名称(方法参数列表){
需要实现的基本行为
}
注意：
1.用来创建对象的方法。
2.当我们创建好一个类以后，默认就有一个无参数的构造方法存在，只是没有显示出来。
3当类中出现有参数的构造方法时，我们最好将无参数的构造方法,手动显示出来，如果没有手动显示出无参数的构造方法，那么有参数的构造方法会将原本默认存在的无参数的构造方法覆盖。
package com.click369.method1;
public class TestMethod3 {
//1.没有方法返回值类型部分
//2.方法的名称与类名称相同
//访问限制修饰符 类名称(方法参数列表){
// 需要实现的基本行为
//}
//用来创建对象的方法
//当我们创建好一个类以后，默认就有一个无参数的构造方法存在，只是没有显示出来。
//当类中出现有参数的构造方法时，我们最好将无参数的构造方法,手动显示出来，
//如果没有手动显示出无参数的构造方法，那么有参数的构造方法会将原本默认存在的无参数的构造方法覆盖。
public TestMethod3(){}
public TestMethod3(String test){
}
}
方法重载----在同一个类中，方法名称相同，参数不同这种现象就是方法重载。
参数不同
- 有或无
- 数量不同
- 类型不同
注意：方法重载与方法的返回值类型，没有关系。
package com.click369.method1;
public class TestMethod4 {
//方法重载与方法的返回值类型，没有关系。
//构造方法重载
public TestMethod4(){}
public TestMethod4(String test){
}
public TestMethod4(String test,int num){
}
public TestMethod4(int num){
}
//实例方法重载
public void test1(){}
public int test1(String test){
return 100;
}
public int test1(int test){
return 100;
}
public void test1(int num1,int num2){}
//静态方法重载
public static void testStatic1(){}
public static int testStatic1(String test){
return 100;
}
public static int testStatic1(int test){
return 100;
}
public static void testStatic1(int num1,int num2){}
}
4.6.同一个类中方法与变量的调用关系？方法与方法的调用关系
同一个类中方法与变量的调用关系
- 在同一个类中只能方法调用变量，不能变量调用方法
同一个类中方法调用变量
package com.click369.test1;
public class TestClassDemo5 {
//实例变量
public int shilibianlang=1001;
//静态成员变量【类变量】
public static String staticbianliang="类变量";
//构造方法
public TestClassDemo5(){}
public TestClassDemo5(int num){
//1.构造方法可以调用实例变量，默认是this.实例变量，this.可以省略
System.out.println(this.shilibianlang);
System.out.println(shilibianlang);
//2.构造方法可以调用类变量，默认是类名.类变量，类名.可以省略，也可以是this.类变量，this.可以省略
System.out.println(TestClassDemo5.staticbianliang);
System.out.println(this.staticbianliang);
System.out.println(staticbianliang);
}
//实例方法
public void test1(){}
public int test2(int num){
//1.实例方法可以调用实例变量，默认是this.实例变量，this.可以省略
System.out.println(this.shilibianlang);
System.out.println(shilibianlang);
//2.实例方法可以调用类变量，默认是类名.类变量，类名.可以省略，也可以是this.类变量，this.可以省略
System.out.println(TestClassDemo5.staticbianliang);
System.out.println(this.staticbianliang);
System.out.println(staticbianliang);
return num;
}
//静态方法【类方法】
//静态方法【类方法】中你绝对不能出现this
public static void teststatic1(){}
public static int teststatic2(int num){
//1.类方法不可以调用实例变量
//System.out.println(this.shilibianlang);
//System.out.println(shilibianlang);
//2.类方法可以调用类变量，默认是类名.类变量，类名.可以省略
System.out.println(TestClassDemo5.staticbianliang);
//System.out.println(this.staticbianliang);
System.out.println(staticbianliang);
return num;
}
}
同一个类中方法调用方法
package com.click369.test1;
public class TestClassDemo6 {
//构造方法
public TestClassDemo6(){}
public TestClassDemo6(int num){
//构造方法可以调用其他的构造方法，new + 其他的构造方法;
new TestClassDemo6();
//构造方法可以调用实例方法，默认this.实例方法，this.可以省略
this.test1();
test1();
//构造方法可以调用类方法,默认类名.类方法，类名.可以省略，也可以是this.类方法，this.可以省略
TestClassDemo6.teststatic1();
this.teststatic1();
teststatic1();
}
//实例方法
public void test1(){}
public int test2(int num){
//实例方法可以调用其他的构造方法，new + 其他的构造方法;
new TestClassDemo6();
//实例方法可以调用其他实例方法，默认this.实例方法，this.可以省略
this.test1();
test1();
//实例方法可以调用类方法,默认类名.类方法，类名.可以省略，也可以是this.类方法，this.可以省略
TestClassDemo6.teststatic1();
this.teststatic1();
teststatic1();
return num;
}
//静态方法【类方法】
//静态方法【类方法】中你绝对不能出现this
public static void teststatic1(){}
public static int teststatic2(int num){
//类方法可以调用其他的构造方法，new + 其他的构造方法;
new TestClassDemo6();
//类方法不可以调用实例方法
//this.test1();
//test1();
//类方法可以调用类方法,默认类名.类方法，类名.可以省略
TestClassDemo6.teststatic1();
//this.teststatic1();
teststatic1();
return num;
}
}
总结：
- 静态方法【类方法】中你绝对不能出现this
- 静态方法【类方法】中不能调用实例变量和实例方法
- 构造方法可以调用实例变量/实例方法，默认是this.实例变量/this.实例方法，this.可以省略。
- 构造方法可以调用类变量/类方法，默认是类名.类变量/类名.类方法，类名.可以省略，也可以是this.类变量/this.类方法，this.可以省略。
- 构造方法可以调用其他的构造方法，new + 其他的构造方法;
- 实例方法可以调用实例变量/实例方法，默认是this.实例变量/this.实例方法，this.可以省略。
- 实例方法可以调用类变量/类方法，默认是类名.类变量/类名.类方法，类名.可以省略，也可以是this.类变量/this.类方法，this.可以省略。
- 实例方法可以调用构造方法，new + 其他的构造方法;
- 类方法可以调用类变量/类方法，默认是类名.类变量/类名.类方法，类名.可以省略。
- 类方法可以调用构造方法，new + 其他的构造方法;
4.7对象是什么？对象如何创建？创建好的对象的作用？
- 我们可以认为类它就是一个模具/图纸，而现在的对象它就是通过这个类创建出来的实体/实例。
- 类—抽象的【不能用的，给你看的】— 设计图纸
- 对象–具体【能用的，给你用的】— 制作出来的实际的实体
- 对象就是通过类创建出来的实体/实例。
- 因此上我们把创建对象的过程就叫实例化。【创建对象】
- 类是创建对象的模具/图纸。
- 对象是通过类制作出来的实际的实体。
- 没有类就没有对象。
- 没有对象类就没有意义。
1. 如何创建对象？
- 对象就是通过类创建出来的实体
- 通过 new + 构造方法 创建的。
- 定义格式：类名 对象名称；
- 创建格式：对象名称=new 构造方法;
- 定义+创建格式: 类名 对象名称=new 构造方法;
public class Student{
}
//定义格式：类名 对象名称；
Student stu1; ====> int num1;
//创建格式：对象名称=new 构造方法;
stu1=new Student(); ===> num1=100;
//定义+创建格式: 类名 对象名称=new 构造方法;
Student stu2=new Student();=====>int num1=100;
1. 对象的作用
- 可以通过对象来调用定义在类中的变量【实例变量/类变量】，和方法【实例方法/类方法】，忽略访问限制修饰符的影响。
- Java程序=对象+消息【类中的变量，方法】
- 其他类中实例变量/实例方法只能对象调用。
- 其他类中类变量/类方法，可以对象调用，也可以类名调用。
package com.click369.test1;
/**
* 学生类
* @author Administrator
*
*/
public class StudentBean {
//成员变量
//1.可以没有初始值
//2.可以在本类中的任意一个方法中被调用
//实例变量
public int stuid;
public String stuname;
public int age;
public String stuaddress;
//类变量
public static String classname;
//构造方法
public StudentBean(){
System.out.println("StudentBean类的无参数构造方法");
}
public StudentBean(String val){
System.out.println("StudentBean类的有参数构造方法，参数val的值是=="+val);
}
//实例方法
public void test1(){
System.out.println("StudentBean类的无参数实例方法");
}
public void test2(int num){
System.out.println("StudentBean类的有参数实例方法，参数num的值==="+num);
}
//类方法
public static void testStatic1(){
System.out.println("StudentBean类的无参数类方法");
}
public static void testStatic2(char ch){
System.out.println("StudentBean类的有参数类方法，参数ch的值==="+ch);
}
}
package com.click369.test1;
/**
* 主类--包含主方法【mian】的类就是主类
* @author Administrator
*
*/
public class TestMain {
//主方法【mian】
public static void main(String[] args) {
//定义对象
StudentBean stu1;
//创建对象
stu1=new StudentBean();
//定义+创建
//StudentBean stu2=new StudentBean("参数是字符串");
//通过对象调用实例变量
stu1.stuid=1001;
stu1.stuname="zhangsan";
stu1.age=23;
stu1.stuaddress="西安";
System.out.println(stu1.stuid+"\t"+stu1.stuname+"\t"+stu1.age+"\t"+stu1.stuaddress);
//通过对象调用实例方法
stu1.test1();
stu1.test2(100);
//类变量可以通过对象调用
stu1.classname="java班";
//类变量也可以通过类名调用
System.out.println("班级名称=="+StudentBean.classname);
//类方法可以通过对象调用
stu1.testStatic1();
//类方法也可以通过类名调用
StudentBean.testStatic2('A');
}
}
4.8.对象的内存分配原理？
对象是通过类创建的，而类是一种复合数据类型，那么对象的内存分配与复合数据类型的内存分配是一致。因此对象的内存分配会在内存的堆区和栈区都有分配。
4.9.对象的使用？
- 以实例方法为例，解释对象调用方法的关系
- 没有参数，没有返回值
- 没有参数，有返回值
- 有参数，没有返回值
- 有参数，有返回值
package com.click369.test2;
public class UserBean {
public void testUser1(){
System.out.println("UserBean类的testUser1的实例方法");
}
}
package com.click369.test2;
/**
* 个人信息类
* @author Administrator
*
*/
public class PersonBean {
//1.没有参数，没有返回值
public void test1(){
System.out.println("没有参数，没有返回值");
}
//2.没有参数，有返回值
public String test2(){
System.out.println("没有参数，有返回值");
return "hello";
}
//3.有参数，没有返回值
public void test3(int num1,double num2){
System.out.println("有参数，没有返回值");
System.out.println("int num1=="+num1);
System.out.println("double num2=="+num2);
}
//4.有参数，有返回值
public double test4(int num1,double num2){
System.out.println("有参数，有返回值");
System.out.println("int num1=="+num1);
System.out.println("double num2=="+num2);
return num1+num2;
}
//5.参数为复合数据类型
public void test5(UserBean user){
System.out.println("参数为复合数据类型");
user.testUser1();
}
//6.返回值为复合数据类型
public UserBean test6(){
System.out.println("返回值为复合数据类型");
//UserBean user=new UserBean();
//return user;
return new UserBean();
}
}
package com.click369.test2;
public class TestMain {
public static void main(String[] args) {
PersonBean person=new PersonBean();
//1.调用没有参数，没有返回值
//person.test1();
//2.调用没有参数，有返回值,创建变量接收方法的返回值结果
//String value=person.test2();
//System.out.println("test2方法的执行结果=="+value);
//3.调用有参数，没有返回值,传入参数值
//person.test3(100, 12.5);
//int a=100;
//double b=12.5;
//person.test3(a,b);
//4.调用有参数，有返回值,传入参数值,创建变量接收方法的返回值结果
//double num=person.test4(100, 12.5);
//System.out.println("test4方法的执行结果=="+num);
//5.调用参数为复合数据类型的方法
//person.test5(new UserBean());
//UserBean user=new UserBean();
//person.test5(user);
//6.调用返回值为复合数据类型的方法
UserBean user=person.test6();
user.testUser1();
}
}
总结：1.先new 2，要什么，给什么 3. 给什么，收什么
4.10.类与对象的关系？
java类和对象的关系是：对象是类实例化出来的,对象中含有du类的属性,类是对zhi象的抽象。
类和对象的区别
1，类是一个抽象的概念，它不存在于现实中的时间/空间里，类只是为所有的对象定义了抽象的属性与行为。就好像“Person（人）”这个类，它虽然可以包含很多个体，但它本身不存在于现实世界上。
2，对象是类的一个具体。它是一个实实在在存在的东西。
3，类是一个静态的概念，类本身不携带任何数据。当没有为类创建任何对象时，类本身不存在于内存空间中。
package com.click369.test2;
public class UserBean {
public void testUser1(){
System.out.println("UserBean类的testUser1的实例方法");
}
}
package com.click369.test2;
/**
* 个人信息类
* @author Administrator
*
*/
public class PersonBean {
//1.没有参数，没有返回值
public void test1(){
System.out.println("没有参数，没有返回值");
}
//2.没有参数，有返回值
public String test2(){
System.out.println("没有参数，有返回值");
return "hello";
}
//3.有参数，没有返回值
public void test3(int num1,double num2){
System.out.println("有参数，没有返回值");
System.out.println("int num1=="+num1);
System.out.println("double num2=="+num2);
}
//4.有参数，有返回值
public double test4(int num1,double num2){
System.out.println("有参数，有返回值");
System.out.println("int num1=="+num1);
System.out.println("double num2=="+num2);
return num1+num2;
}
//5.参数为复合数据类型
public void test5(UserBean user){
System.out.println("参数为复合数据类型");
user.testUser1();
}
//6.返回值为复合数据类型
public UserBean test6(){
System.out.println("返回值为复合数据类型");
//UserBean user=new UserBean();
//return user;
return new UserBean();
}
}
package com.click369.test2;
public class TestMain {
public static void main(String[] args) {
PersonBean person=new PersonBean();
//1.调用没有参数，没有返回值
//person.test1();
//2.调用没有参数，有返回值,创建变量接收方法的返回值结果
//String value=person.test2();
//System.out.println("test2方法的执行结果=="+value);
//3.调用有参数，没有返回值,传入参数值
//person.test3(100, 12.5);
//int a=100;
//double b=12.5;
//person.test3(a,b);
//4.调用有参数，有返回值,传入参数值,创建变量接收方法的返回值结果
//double num=person.test4(100, 12.5);
//System.out.println("test4方法的执行结果=="+num);
//5.调用参数为复合数据类型的方法
//person.test5(new UserBean());
//UserBean user=new UserBean();
//person.test5(user);
//6.调用返回值为复合数据类型的方法
UserBean user=person.test6();
user.testUser1();
}
}
总结：1.先new 2，要什么，给什么 3. 给什么，收什么
4.10.类与对象的关系？
java类和对象bai的关系是：对象是类实例化出来的,对象中含有du类的属性,类是对zhi象的抽象。
类和对象的区别
1，类是一个抽象的概念，它不存在于现实中的时间/空间里，类只是为所有的对象定义了抽象的属性与行为。就好像“Person（人）”这个类，它虽然可以包含很多个体，但它本身不存在于现实世界上。
2，对象是类的一个具体。它是一个实实在在存在的东西。
3，类是一个静态的概念，类本身不携带任何数据。当没有为类创建任何对象时，类本身不存在于内存空间中。
4，对象是一个动态的概念。每一个对象都存在着有别于其它对象的属于自己的独特的属性和行为。对象的属性可以随着它自己的行为而发生改变。