标签：Java 构造方法 int 第三周 System 学习 println public out
方法:
就是使用功能代码块{}(代码块)将核心功能使用{}包起来,并为之起一个名字(符号标识符的规则)即可!
Java中方法的定义格式分两种情况
1)有具体返回值类型的方法定义
2)没有具体返回值类型的方法定义
1.有具体返回值类型固定格式:
权限修饰符 static 返回值类型 方法名(形式参数类型1 变量名1,形式参数类型2 变量2....){ //功能业务操作
return 结果;
}
public static 返回值类型 方法名(形式参数类型1 变量名1,形式参数类型2 变量2....){
//功能业务操作
return 结果;
}
解释:
权限修饰符:现在方法访问权限:公共的/公开的,访问权限足够大,public
static:面向对象在讲,目前来说必须带上static
返回值类型:数据类型 (目前使用的基本类型)
方法名:见名知意,满足标识符的规则...(小驼峰命名法)
形式参数类型:数据类型(目前使用的基本类型)
变量名:定义参数名称 (见名知意)满足标识符的规则...(小驼峰命名法)
有具体返回值类型的方法调用
方法名(实际参数) ;
1)单独调用:没有输出
2)输出调用:可以用,不建议用,因为如果需要将结果进一步操作,写死,不太好!
3)赋值调用:推荐
有返回值类型方法调用:赋值调用
返回值类型 变量名 = 方法名(实际参数名1,实际参数名2....);
使用变量名即可!
eg:
class FunctionDemo{
public static void main(String[] args){ //能够jvm识别调用,程序的入口
//实际参数:可以键盘录入/也可以直接定义
//定义两个变量
int a = 10 ;
int b = 20 ;
//1)单独调用
//add(a,b) ; 没有输出结果
//2)输出调用:可以用,不建议用,因为如果需要将结果进一步操作,写死,不太好!
//System.out.println("两个数据之和是:"+add(a,b)) ;
//3)赋值调用:推荐
int result = add(a,b) ;
System.out.println("两个数据之和是:"+result);
}
/*
求两个数据之和,使用方法来完成! 默认都是int
public static 返回值类型 方法名(形式参数类型1 变量名1,形式参数类型2 变量2....){
//功能业务操作
return 结果;
}
心中:两个明确
1)明确返回值类型 int
2)明确参数类型以及参数个数
int 2个
*/
public static int add(int a,int b){
//功能业务操作
int c = a+ b;
return c ;
}
}
Java中定义方法和调用方法的注意事项(有返回值类型的方法)
1)方法和方法是平级关系,在一个方法中不能嵌套定义另一个方法
2)Java是一个强类型语言,定义方法的时候,形式参数类型必须携带,不能省略!
后期学习前端javascript:弱类型语言
function add(a,b){}
3)调用方法的时候,实际参数不需要携带数据类型的
4)定义方法的时候,后面千万不能来一个分号,这个方法缺少方法主体的,没有意义!
有{左大括号的地方不能有分号;
有;号的地方不能有{左大括号
public static int add(int a,int b);
{ 没有意义
return a + b ;
}
2)没有具体返回值类型的方法格式:
权限修饰符 静态修饰符static 返回值类型 方法名(形式参数列表...){
..
}
"直接在控制台打印数据"
没有具体返回值,Java有一个规定,
遵循上面方法定义格式,使用关键字void 代替了返回值类型(只是为了填充语法格式)
public static void main(String[] args){}
没有具体返回值类型方法定义格式:固定写法
public static void 方法名(参数类型1 变量名1,参数类型2 变量名2....){
输出语句/或者数据交换...
}
没有具体返回值类型方法调用:
1)单独调用:推荐!
方法名(实际参数列表) ;
2)输出调用:不行
3)赋值调用:不行
class FunctionDemo3{
public static void main(String[] args){
//for循环嵌套:
//外层for:控制行数
//内层for:控制列数
for(int x = 0 ; x < 4 ; x ++){//控制行数
for(int y = 0 ; y < 5 ; y ++){//控制列数
System.out.print("*") ;
}
System.out.println() ;
}
System.out.println("-------------------------------------------") ;
//将上面封装到代码块中
//调用方法来完成
//: 非法的表达式开始 :不能用void result = printXing(5,6) ;
//System.out.println(result) ;
//输出调用:不能用 非法表达式
//System.out.println(printXing(5,6)) ;
//单独调用即可:推荐
System.out.println("-------------------------------------------") ;
printXing(4,5) ;
System.out.println("-------------------------------------------") ;
printXing(5,6) ;
System.out.println("-------------------------------------------") ;
printXing(7,8) ;
}
public static void printXing(int m,int n){//m:行,n:列
for(int x = 0 ; x <m ; x ++){//控制行数
for(int y = 0 ; y< n ; y ++){//控制列数
System.out.print("*") ;
}
System.out.println() ;
}
}
}方法重载(OverLoad)
标识符的规则:见名知意 ---现在的功能都是"求和",那么Java中多个方法的功能如果一样的,
那么这些方法名字可以同名-----> 方法重载(OverLoad)
方法重载:
多个方法名相同,参数列表不同,与返回值无关
参数列表不同:
1)参数个数不同
2)参数类型不同
3)考虑类型顺序
public static int sum(double a,int b){}
public static int sum(double a,int b,int c){}
public static double sum(int a,double b){}
public static float sum(float a,float b){}
public static float Sum(float a,float b){} :不是重载
方法重载的目的:就是为了让这个功能扩展性更多;方法中接收常用的一些数据类型参
面向对象中:继承中: 方法重写(Override)
class FunctionDemo4{
public static void main(String[] args){
//分别测试:
//调用两个数据之和的方法
System.out.println(sum(10,20)) ;
//System.out.println(sum2(10,20,30)) ;
//System.out.println(sum3(10,20,30,40)) ;
//System.out.println(sum4(10.11,1.34)) ;
System.out.println(sum(10,20,30)) ;
System.out.println(sum(10,20,30,40)) ;
System.out.println(sum(10.11,1.34)) ;
}
/*
求两个数据之和的方法
两个明确
1)明确返回值类型:int
2)明确参数类型以及参数个数:
int,2个
*/
public static int sum(int a,int b) {
return a+ b;
}
//定义三个数据之和的方法
//public static int sum2(int a,int b,int c){
//改进之后:按照方法重载的概念
public static int sum(int a,int b,int c){
return a + b + c ;
}
//定义四个数据之和的方法
//public static int sum3(int a,int b,int c,int d){
//改进
public static int sum(int a,int b,int c,int d){
return a + b + c + d;
}
//public static double sum4(double a,double b){
public static double sum(double a,double b){
return a + b ;
}
}
数组:
是只能够存储同一种类型的容器,在同一数组中,元素的数据类型必须一致!
数组定义格式:
数据类型[ ] 数组名称; int[ ] arr ; 定义了一个int类型的数组变量arr
数据类型 数组名称[ ] ; int arr[ ] ; 定义了一个int类型的arr数组变量
数据类型:学习基本数据类型
数组初始化的第一种方式:
1)动态初始化: 我们给定数组的长度,元素由系统(Jvm)默认初始化
数据类型[] 数组名称 = new 数据类型[长度] ; 推荐第一种
数据类型 数组名称[] = new 数据类型[长度] ;
创建一个数组对象
int[] arr = new int [3] ;
int arr[] = new int [3] ;
数组初始化的第二种方式:
2)静态初始化:我们给出具体的元素内容,系统默认分配长度
数据类型[] 数组名称 = new int[]{元素1,元素2,元素3,.....} ; 推荐第一种
数据类型 数组名称[] = new int[]{元素1,元素2,元素3,.....} ;
简化格式:书写代码简单
数据类型[] 数组名称 = {元素1,元素2,元素3,.....} ;
数据类型 数组名称[] = {元素1,元素2,元素3,.....} ;
举例:
int[] arr = new int[]{1,2,3,4,5,6} ;
简化格式:
int[] arr = {1,2,3,4,5,6} ;
注意事项:
数组的初始化:要么动态初始化/要么静态初始化,不能"动静结合"
int[] arr = new int[3]{1,2,3} ; 错误的!
数组就是引用类型,引用类型下面经常会出现异常:
运行时期异常:
ArrayIndexOutOfBoundsException:数组角标越界异常
NullPointerException:空指针异常
程序在过程中,经常会出现"异常"; 后期常用类中讲
程序有问题
1)编译时期异常:jvm检查语法不通过; 语法格式存在问题
举例:
同一个变量被定义多次
数组格式写错
...
2)运行时期异常:开发者:代码书写不严谨导致的问题
键盘录入: 代码书写---->录入int类型
int num = 键盘录入对象.nextInt() ;
java.lang.ArrayIndexOutOfBoundsException:数组角标越界异常
出现的原因:访问了数组中不存在的角标(索引值)
如何解决:检查代码,更改索引值
java.lang.NullPointerException:空指针异常
引用类型的默认值都是null;
String s = null ; 字符串是一种特殊的引用类型
出现的原因:某一个对象已经为空了,null(没有堆内存地址),这个时候还要去访问元素或者调用
这个对象的方法,那么就出现空指针;
如何解决:
使用逻辑判断语句,对该对象进行非空判断
面向对象:
完成某一件事情,从分析,到实现,都是自己亲力亲为完成的!
面向对象的代表语言:Java,c++,python...
面向对象跟面向过程:生活中处处皆对象
举例:
洗衣服这件事情
面向过程:
1)脱下脏衣服--->2)找一个盆子-----3)放入洗衣液-----4)泡一泡-----5)搓一搓-----6)透水
----7)拧一拧----->8)抖一抖-----9)晾一晾
面向对象:
1)脱下脏衣服---->2)全自动洗衣机(一键)----->3)晾一晾
面向对象的思想特点:
1)更符合我们生活中思想行为习惯
2)让更复杂的事情简单化
3)角色发生了变化:我们从执行者变成了指挥者!
Java语言:面向对象语言---->它的设计原则
在程序中(符合生活中的场景),不断的创建对象,使用对象,指挥对象做事情(完成功能...)
举例:
1)创建键盘录入对象:Scanner
2)录入int类型/String类型数据
Java语言面向对象的三大特征: 封装,继承,多态!
1.类:能够描述一组事物的属性和行为的集合
类------>能够描述现实世界真实存在的 "事物"
学生事物
属性:性别,年龄,姓名,学号,身高,班级,体重... 能够描述一个学生具体特点
行为: 主要的行为:学习, 吃,睡,玩.. 能够描述学生干什么
现在使用Java代码的方式 描述现实世界存在的事物
Java中最基本的单元:类 -----> 事物
成员变量-------> 描述事物的属性
成员方法(非静态的)-------> 描述事物的行为
成员变量: 在类中,方法外;
成员方法: 之前怎么定义方法,现在还怎么写,不过,去掉static关键字
public 返回这里类型 方法名(形式参数列表){
业务体
//有具体结果1)return 结果 ;
//没有具体结果:输出 打印...
}
定义:
两个明确
1)明确返回值 :有-->给具体类型 ,没有:void 代替 输出结果
2)明确参数类型,以及参数个数
具体情况,具体分析
2.类与对象的关系
类----描述真实事物的
学生事物
属性:
姓名
年龄
住址
..
行为:
学习JavaSE
学生类
class Student{
//成员变量 ---事物属性
String name ;//姓名
int age ;//年龄
String address;//住址
//...
//成员方法----事物的行为
public void study(String name){
System.out.println("正在学习"+name) ;
}
}
什么是对象?
体现出 "具体的事物" 因为类---描述事物----概括的事物("总称")
在测试类中使用:main方法所在类
代码体现:
格式:
类名 对象名 = new 类名() ;
给具体事物属性赋值
对象名.成员变量 = 根据类型赋值;
调用具体事物的行为
对象名.成员方法名() ;
局部变量和成员变量区别
1)在类中的书写位置区别
局部变量:在方法定义中或者是方法声明上;
成员变量:在类中,方法外;
2)在内存中的位置不同
局部变量:在栈内存中
成员变量:在堆内存中
3)生命周期不同:
局部变量:随着方法调用而存在,随着方法调用结束而消失
成员变量:随着对象的创建而存在,随着对象的调用完毕,等待垃圾回收器空闲时候回收,不会立即消失!
4)初始化时机不同:
局部变量:
要么先定义,使用之前必须初始化;要么直接初始化
成员变量:
可以不赋值,系统默认对成员变量初始化
也可以通过对象名.成员变量 =赋值;
class Variable{
//成员变量
int num ;
//成员方法
public void show(int a){//局部变量
int b ; //可能尚未初始化变量b
//要么先定义,使用之前,初始化;要么直接初始化
System.out.println(a) ;
b = 20 ;
System.out.println(b) ;
}
}
//测试类
class VariableDemo{
public static void main(String[] args){
//访问num变量如何访问?
//创建当前类Variable对象
//类名 对象名= new 类名() ;
Variable v = new Variable() ;
System.out.println(v.num) ;
v.num = 10 ;
System.out.println(v.num) ;
System.out.println("-------------------") ;
v.show(100) ;
}
}匿名对象: 顾名知意:没有名字的对象
创建对象的格式:
类名 对象名 = new 类名() ;
Student s = new Student() ;
匿名对象的格式:
new 类名() ;
好处:
1)节省内存空间
2)开发中,匿名对象一般 使用"一次即可",使用完毕就立即垃圾回收器回收!
3)手机移动端/Android/鸿蒙系统:基于Java语言
ios系统:基于c语言
访问类的成员变量:
new 类名().成员变量名;
访问类的成员方法:没有具体返回值类型
new 类名().成员方法名() ;
封装
private:私有的,不能直接访问的;
特点:
被private修饰的成员变量或者是成员方法,只能在本类中访问;
外界类是不能直接访问的,间接可以通过公共的成员方法访问!
限修饰符:
private :最小
public: 最大
class Demo{
//公共的成员变量
public int num = 100 ;
private int num2 = 200 ;
//定义一个公共方法
public void show(){
System.out.println(num) ;
System.out.println(num2) ;
}
//定义一个公共的成员方法
public void method(){
System.out.println("hello,method...") ;
System.out.println("------------------------") ;
function();
}
//定义一个私有的成员方法
private void function(){
System.out.println("hello,function...") ;
}
}
//测试类
class PrivateDemo{
public static void main(String[] args){
//需求:访问Demo类的num
//创建Demo类对象
Demo d = new Demo() ;
System.out.println(d.num) ;
System.out.println("--------------------------") ;
//System.out.println(d.num2) ;//错误: num2 在 Demo 中是 private 访问控制
//通过公共方法间接访问私有的成员变量
d.show() ;
System.out.println("--------------------------") ;
//对象名.成员方法名();
d.method() ; //间接访问公共访问---访问的私有方法;
//d.function();// function() 在 Demo 中是 private 访问控制
}
}this关键字:
定义一个学生类:Student
成员变量:私有化----加入private
name,age,gender,id,hobit
成员方法:
setXXX()/getXXX():给学生信息赋值/获取值
study(),playFootball(),watchMove()
代码存在弊端:
讲标识符:在实际开发中,起名字(变量/方法/类)见名知意
当前代码中的setXXX(形式参数):都是 n,a,g,i,h:不太合适
既然见名知意:
name,赋值一个姓名
age:赋值年龄
gender:赋值性别
id:赋值学号
hobit:赋值爱好
局部变量名称和成员变量名称一致(局部变量隐藏了成员变量),Java提供了一个关键字:this
this:代表当前类对象的地址值引用
构造方法:构造方法是一种特殊的方法,方法名和类名一致;
特点:
1)方法名和类名一致;
2)构造方法没有返回值类型
3)连void都没有
构造方法是重载的!
方法重载:
方法名相同,参数列表不同,与返回值无关!
参数列表不同:
参数个数
参数类型
考虑类型先后属性
分类:
无参构造方法:没有参数
有参构造方法:有具体的参数类型
构造方法的作用:就是对类中的数据(成员属性)进行初始化
class Student{
//显示给出了 无参构造方法
public Student(){
System.out.println("这是Student类的无参构造方法...") ;
}
//有参构造方法
public Student(String name){
System.out.println("这是Student类的带String类型的有参构造方法...") ;
}
//带两个参数的构造方法
public Student(String name,int age){
System.out.println("这是带两个参数的有参构造方法....") ;
}
}
//测试类
class ConstructorDemo{
public static void main(String[] args){
//创建学生类对象
Student s = new Student() ;
System.out.println(s) ;//Student@6d06d69c
/*
这是Student类的无参构造方法...
Student@6d06d69c
*/
System.out.println("---------------------------") ;
//创建学生对象
Student s2 = new Student("高圆圆") ;
System.out.println(s2) ;
System.out.println("---------------------------") ;
//在创建学生对象
Student s3 = new Student("高圆圆",42) ;
System.out.println(s3) ;
/*
这是带两个参数的有参构造方法....
Student@4e25154f
*/
}
}构造方法的注意事项:
1)当我们开发者既没有提供无参构造方法,也没有提供有参构造方法,
系统永远给我们提供 "无参构造方法"
类名 对象名 = new 类名() ; //创建对象的格式
2)如果我们提供了有参构造方法,那么系统不会在提供无参构造方法
构造方法的作用:给类的成员属性可以进行数据初始化
给成员变量(私有修饰)赋值几种方式:
1)公共的访问方法setXXX(xx):赋值
2)有参构造方法进行赋值
public 类名(参数类型1 变量名1,参数类名2 变量名2...){
this.成员变量名1 = 变量1;
this.成员变量名2 = 变量2 ;
...
}
class Teacher{
//提供两个属性 :属性私有化
private String name ;//姓名
private int age ; //年龄
//没有提供任何构造方法
//提供无参构造方法
public Teacher(){
}
//只是提供有参构造方法
public Teacher(String name,int age){//"高圆圆",42
//局部变量隐藏成员变量:通过this区分
this.name = name ;
this.age = age ;
}
//提供setXXX()/getXXX()
public void setName(String name){
this.name = name ;
}
public String getName(){
return name ;
}
public void setAge(int age){
this.age = age ;
}
public int getAge(){
return age ;
}
//老师学习/讲课的方法...
}
//测试类
class ConsturctorDemo2{
public static void main(String[] args){
//创建Teacher类对象
Teacher t = new Teacher() ;
//通过setXXX(xx);赋值
t.setName("苍井空") ;
t.setAge(18) ;
System.out.println(t.getName()+"---"+t.getAge()) ;
System.out.println("-------------------------------") ;
//通过有参构造方法也可以赋值
Teacher t2 = new Teacher("高圆圆",42) ;
System.out.println(t2.getName()+"---"+t2.getAge()) ;
}
}一个标准类的写法:
使用学生类描述学生事物,并且进行测试
学生事物的属性
姓名,年龄,性别
学生事物的行为:
学习,玩游戏
定义学生类
成员变量:私有化
name,age,gender
构造方法:
无参/有参构造方法
成员方法:
setXXX(xx),getXXX()
study(),playGame()
class Student{
//成员变量私有化
private String name ;//姓名
private int age ; //年龄
private String gender ; //性别
//无参构造方法
public Student(){
}
//有参构造方法
public Student(String name,int age,String gender){
this.name = name ;
this.age = age ;
this.gender = gender ;
}
//对外的公共访问方法setXXX(xx)/getXXX()
public void setName(String name){
this.name = name ;
}
public String getName(){
return name ;//获取学生姓名
}
public void setAge(int age){
this.age = age ; //给学生年龄赋值
}
public int getAge(){
return age ; //获取学生年龄
}
public void setGender(String gender){
this.gender = gender ;//给学生性别赋值
}
public String getGender(){
return gender ;//获取学生的性别
}
//其他的成员方法
public void study(){
System.out.println("正在学习面向对象之标准类的写法...") ;
}
public void playGame(String gameName){
System.out.println("学习困了,可以玩一把"+gameName+",在楼下玩") ;
}
}
//测试类
class StudentTest{
public static void main(String[] args){
//方式1:测试
//无参构造方法+setXXX(xx)/getXXX()
//创建学生类对象
Student s = new Student() ;
s.setName("高圆圆") ;
s.setAge(42) ;
s.setGender("女") ;
System.out.println("该学生的姓名是"+s.getName()+
",年龄是:"+s.getAge()+",性别为:"+s.getGender()) ;
s.study() ;
s.playGame("王者农药") ;
System.out.println("---------------------------------------") ;
//方式2:测试
//有参构造方法+getXXX()
Student s2 = new Student("赵又廷",45,"男") ;
System.out.println("该学生的姓名是"+s2.getName()+
",年龄是:"+s2.getAge()+",性别为:"+s2.getGender()) ;
s2.study() ;
s2.playGame("吃鸡") ;
}
}标签：Java,构造方法,int,第三周,System,学习,println,public,out 来源： https://blog.csdn.net/A57i_/article/details/120633269
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。