一.键盘录入的三种格式
键盘录入有三种方式
1 . 早期的 main(String[] args)
String[]:字符串数组
args:形式参数名
弊端:只能接收字符串
javac Demo.java ---- >Demo.class
java Demo hello world java
2 . 方式2:JD5以后使用的:Scanner:文本扫描器
导包:import java.util.Scanner;
3 . 第三种方式:利用的BufferedReader:字符缓冲输入流 (IO流部分)
功能:readLine() :读取一行内容
java.io.BufferedReader;
二.方法的形式参数传递
方法的形式参数传递:
-
基本数据类型作为参数传递:四类八种
基本类型作为形式参数传递，形参的改变不影响实际参数! -
引用类型作为参数传递:数组,类,接口
引用类型作为形式参数（数组、类、接口），形式参数的改变会直接影响实际参数(String除外,它作为参数传递和基本类型作为参数传递效果一致!)
String特点:字符串是常量
数组作为形式参数，引用类型如果是数组，需要传递的是该数组的对象！（空间地址值）
class ArgsDemo{
public static void main(String[] args){
//定义两个变量a,b
int a = 10 ;
int b = 20 ;
System.out.println("a:"+a+",b:"+b) ;//10,20
change(a,b) ;
System.out.println("a:"+a+",b:"+b) ;//10,20
System.out.println("---------------------------") ;
//创建一个数组,静态初始化
int[] arr = {1,2,3,4,5} ;
System.out.println(arr[3]) ; //4
change(arr) ;
System.out.println(arr[3]) ; //8
System.out.println("---------------------------") ;
//String作为引用类型(特殊的引用类型)作为参数传递
String s = "hello" ;
System.out.println(s) ;
change(s) ;
System.out.println(s) ;
}
public static void change(String s){
System.out.println(s) ;
s += "gaoyuanyuan" ;
System.out.println(s) ;
}
//重载的change方法
public static void change(int[] arr){
//遍历数组
for(int x = 0 ; x < arr.length ; x ++){
if(arr[x] % 2 ==0){
arr[x] *= 2 ;
}
}
}
public static void change(int a,int b){
System.out.println("a:"+a+",b:"+b) ;//10,20
a = b ; // a = 20
b = a + b ; // b = 20 + 20 = 40
System.out.println("a:"+a+",b:"+b) ;//20,40
}
}
三.面向对象
面向对象的思想：面向对象是基于面向过程的!
面向对象的思想特点:
- 让复杂的事情简单化
- 让我们从执行者变成了指挥者(角色发生了变化)
- 更符合我们生活中的思想行为习惯…
面向过程:
从需求分析,到业务逻辑,以及结果输出:整个过程都是自己完成(自己是一个执行者!)
举例:
生活的例子 (生活中处处都是对象)
面向过程：买电脑
自己关注哪些配置—>去赛格电脑城—>砍价—>付费—>发现被坑了 ---->买回来
洗衣服：有一些脏衣服—>使用洗衣盆放入洗衣液—>接水—>泡一泡—>搓一搓—>甩一甩—>拧一拧—>晾衣服
面向对象:买电脑
关注哪些配置---->找一个懂行的朋友---->买到电脑
洗衣服：有一些脏衣服—>全自动洗衣机(一键)/找一个对象—>晾衣服
面向对象的设计原则 ：在不断的创建对象,使用对象,指挥对象做事情
举例: 键盘录入Scanner
需求：创建文本扫描器对象,使用这个对象录入int类型,double,String类型等等一些数据，然后完成相应的操作!
赵本山---->“将大象装进冰箱”
面向过程思想:
伪代码
class Demo{
public static void main(String[] args){
open() ;
in();
close() ;
}
//定义功能:冰箱的开门
public static void open(){
System.out.println("打开冰箱门...") ;
}
//将大象装进去的功能
public static void in(){
System.out.println("将大象装进去...") ;
}
//定义:关闭冰箱门
public static void close(){
System.out.println("关闭冰箱门...") ;
}
}
面向对象: “将大象装进冰箱”
名词提前法:
1)有哪些类(真实存在的事物)：Demo:测试类；大象类；冰箱类
2)有哪些方法(功能)：大象；进去的功能；冰箱：开和关的功能
宗旨：不断的创建对象,使用对象,指挥对象做事情(功能的调用)
class Demo{
public static void main(String[] args){
//创建冰箱类对象
冰箱类对象.open() ;
创建大象类对象
大象类对象.in() ;
冰箱类对象.close() ;
}
}
class 大象类{
public void in(){
System.out.println("大象进去...") ;
}
}
class 冰箱类{
public void open(){
System.out.println("开门...") ;
}
public void close(){
System.out.println("关门...") ;
}
}
面向对象的三大特征: 封装、继承、多态
四.类与事物的关系
事物:是能够描述现实世界中真实存在的泛指的东西
学生----->学生事物
Java中,最基本的单元是类:class
类:是能够描述一组事物的属性和行为的集合!
学生事物
属性:姓名,年龄,学号,班级,身高,性别...
行为:主要都是学习,吃,睡,玩游戏...
使用Java代码的方式描述上面的学生事物:
定义一个类:学生类 class Student{}
成员变量(在类中,方法外定义):name,age,stuId,gender,hight...
成员方法:(去掉static关键字): 之前的方法怎么定义,现在还怎么定义,只是去掉static即可!
study(),eat(),sleep(),playGame()...
长方形----->长方形事物
属性:长和宽
行为:周长和面积
定义一个长方形类
成员变量:length,width
成员方法:getLength(),getArea()
类和对象:
类:一组事物的属性和行为的集合! 学生类 Student
对应的真实存在事物(泛指) 学生事物
对象: 描述的应该真实事物中的具体的!
学生事物
高圆圆(具体事物),20岁,喜欢lol
代码实现:
创建对象
类名 对象名 = new 类名();
对象名.成员变量= 赋值
对象名.成员方法() ; 使用这个方法
五.成员变量和成员方法
成员变量：能够描述事物的特有属性
人（姓名，年龄，性别…）在类中方法外定义，可以不初始化.
成员方法：能够描述事物的行为（能做什么）
人（基本：吃，睡，玩）
学生事物:
属型:姓名,年龄,性别,身高
行为:学习,玩游戏…
学生类:Student
成员变量
成员方法
使用Java面向对象的编程方式:定义学生类并且在 StudentTest类中测试一下
class Student{
//将学生事物的属性----定义为成员变量:类中,方法外
String name ;//姓名
int age ;//年龄
String gender;//性别
int hight ; //身高
//学生事物的行为---->成员方法:去掉static
public void study(){
System.out.println("学习JavaSE...") ;
}
public void playGame(String gameName){//传递一个参数:游戏名称
System.out.println("正在玩"+gameName) ;
}
}
//学生类的测试类
class StudentTest{
public static void main(String[] args){
//测试学生类
//创建一个对象(代表:具体的学生事物)
//类名 对象名 = new 类名();
Student student = new Student() ;
System.out.println(student.name+"---"+student.age+"---"+student.gender+"---"+student.hight) ;
//对象名.成员变量=赋值
student.name = "高圆圆" ;
student.age = 41 ;
student.gender ="女" ;
student.hight=182 ;
System.out.println(student.name+"---"+student.age+"---"+student.gender+"---"+student.hight) ;
//对象名.成员方法() ;
student.study() ;
student.playGame("吃鸡") ;
}
}
手机事物:
- 属性:品牌,价格,颜色
- 行为:打电话,发短信,玩游戏
定义一个Phone类
成员变量:品牌(brand),价格(price),颜色(phoneColor)
成员方法:callPhone(String name),sendMsg(),playGame()
创建两个手机类对象,给成员变量赋值,调用成员方法,在phoneTest2类中测试
class Phone{
String brand ;
int price ;
String color ;
//成员方法
public String callPhone(String name){
return "给"+name+"可以打电话" ;
}
public void sendMsg(){
System.out.println("手机可以发短信...") ;
}
public void playGame(){
System.out.println("手机可以玩游戏...") ;
}
//定义一个成员方法:目的 就将成员变量信息输出
public void show(){
System.out.println(brand+"---"+price+"---"+color) ;
}
}
class PhoneTest2{
public static void main(String[] args){
//创建第一个手机类对象
Phone p1 = new Phone() ;
p1.brand = "Iphone12" ;
p1.price = 4599 ;
p1.color = "土豪金" ;
System.out.println(p1.brand+"---"+p1.price+"---"+p1.color) ;
String s = p1.callPhone("张三") ;
System.out.println(s) ;
p1.sendMsg() ;
p1.playGame() ;
System.out.println("--------------------------------------") ;
Phone p2 = new Phone() ;
p2.brand = "华为mate40pro保时捷版" ;
p2.price = 12999 ;
p2.color = "天空灰" ;
p2.show() ;
String s2 = p2.callPhone("张三") ;
System.out.println(s2) ;
p2.sendMsg() ;
p2.playGame() ;
System.out.println("--------------------------------------") ;
//将p1赋值p3对象
Phone p3 = p1 ;
p3.brand = "锤子" ;
p3.price = 1999 ;
p3.color = "黑色" ;
System.out.println(p1.brand+"---"+p1.price+"---"+p1.color) ;
//System.out.println(p1==p2) ;//引用类型比较:比较的是地址值是否相同!
//int a = 10 ;
//int b = 20 ;
//System.out.println(a == b); //基本数据类型:比较的是数据值是否相同
}
}
局部变量和成员变量的区别?
-
代码的书写位置不同
局部变量: 在方法定义中或者是方法声明上的变量
成员变量:类中方法外 -
内存中的位置不同
局部变量: 在栈内存中
成员变量: 在堆内存中 -
生命周期不同
局部变量: 随着方法调用而存在,随着方法的调用结束而消失!(使用完毕,立即消失了)
成员变量: 随着类的加载而存在,随着类的加载完毕,等待垃圾回收器自动回收而消失!
(对象创建完毕,对象可能被继续使用,所以不会立即消失!) -
初始化不同:
局部变量: 定义的时候,使用前必须初始化; 要么就是直接初始化,不能没有初始化值!
成员变量: 随着类的加载而存在,存在系统默认初始化,可以不直接赋值! 也可以赋值(不推荐)
class Variable{
//成员变量
int num = 10 ;
public void show(){ //方法声明上
//int a = 20 ;//方法定义中
//System.out.println(a) ;
//int b ;没有赋值
int b ;
b = 10 ;
System.out.println(b) ;
}
}
//测试类
class VariableDemo{
public static void main(String[] args){
//需求:要访问Variable类中的num变量,如何访问
//创建Variable类的对象访问
//类名 对象名 = new 类名();
Variable v = new Variable() ;
System.out.println(v.num) ;
v.num = 200 ;
System.out.println(v.num) ;
v.show() ;
}
}
六.引用类型作为参数传递
形参是引用类型和基本类型的区别是什么？
- 基本类型作为形式参数传递,形式参数的改变不会影响实际参数!
- 引用类型在作为参数传递,形式参数的改变会直接影响实际参数!(除了String字符串之外)
数组,类,接口
类: 具体类:实际参数传递需要的是该类的对象!(空间地址值)
//定义一个学生类
class Student{
//定义一个成员方法
public void study(){
System.out.println("Good Good Study ,Day Day Up!!!") ;
}
}
//定义一个类StudentDemo类
class StudentDemo{
//有一个成员方法:method
public void method(Student s){//形式参数是Student类型
s.study() ; // 形式参数变量s.study():s应该在传递----学生类的对象!
}
}
//测试类
class StudentTest{
public static void main(String[] args){
//需求:要访问StudentDemo类中method 方法如何访问?
//创建StudentDemo类的对象
StudentDemo sd = new StudentDemo() ;
//method方法中的参数传递:实际参数需要的是Student的具体对象
Student student = new Student();
sd.method(student) ; //实际参数是什么?
}
}
五.匿名对象
匿名对象: 没有名字的对象!
格式: new 类名() ;
特点:
- 开发中使用一次即可
- 使用完毕,立即被回收,可以结束内存空间!
这种写法针对:移动端: Android(考虑内存问题) - 作为参数传递
pc端: 推荐: 类名 对象名 = new 类名() ;
class Student{
//成员方法
public void study(){
System.out.println("爱生活,爱Java...") ;
}
}
class StudentDemo{
public void method(Student s){
s.study() ;
}
}
//测试类中
class NoNameDemo{
public static void main(String[] args){
//需求:访问StudentDemo类中method
//分步骤:
//创建StudentDemo类的对象
StudentDemo sd = new StudentDemo() ;
//创建一个具体的学生类对象
Student student = new Student() ;
sd.method(student) ;
System.out.println("-----------------------") ;
//链式编程
//匿名对象(只限于自己玩,开发中正常使用有名字的对象)
new StudentDemo().method(new Student()) ;
}
}
扫一扫
3578
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
