/**
* 成员变量和局部变量的区别 (面试题---基础面向对象面试题中:问的频率很高的)
* 1)书写位置不同
* 局部变量:在方法定义中或者方法声明上
* 成员变量:在类中方法外 (范围大)
* 2)内置中的位置不同
* 局部变量:在栈内存中
* 成员变量:在堆内存中
* 3)生命周期不同
*
* 局部变量: 随着方法调用而存在,随着方法调用结束而消失
* 成员变量:随着对象的创建而存在, (跟对象有关系:类名 对象名= new 类名();)
* 随着对象的创建完毕等待垃圾回收器空闲的时候回收掉,而消失!
*
* 4)初始化值不同
* 局部变量:要么先定义,后面初始化;要么直接直接初始化
* 在使用之前必须初始化,否则报错 "可能尚未初始化变量"
* 成员变量:存在系统默认初始化,可以不赋值,可以赋值,但是不一般不会直接赋值(笔试题中可能出现,直接赋值)
* 都是通过对象名.成员变量名=赋值;
*
*///定义一个类Variable class Variable{ //成员变量 public int num ; //类中方法外 public void show(String str){ //str,num都是局部变量(方法定义中或者方法声明上) int num2 = 100; System.out.println(str+num2); } } //测试类 public class VariableDemo { public static void main(String[] args) { //访问Variable类中的num变量,如何访问? Variable variable = new Variable() ; variable.num = 200 ; //赋值 System.out.println(variable.num) ; //访问成员方法 variable.show("hello"); } }
/**
* idea中的神键: alt+enter--- 代码提示,补全代码... 类似于eclipse中的alt+/
*
*
方法形式参数问题
(如果是基本类数据/引用数据类型作为形参的区别) (很重要,面试题)看程序,写结果 --考点(形式参数是基本数据类型,引用数据:数组) 形式参数如果是基本数据类型,形参的改变不会影响实际参数
*/public class Test { public static void main(String[] args) { //有两个变量 int a = 10 ; int b = 20 ; System.out.println("a:"+a+",b:"+b) ;//10,20 change(a,b) ;//实际参数 System.out.println("----------------------") ; System.out.println("a:"+a+",b:"+b) ;//10,20 } private static void change(int a, int b) { //形式参数是基本数据类型 System.out.println("a:"+a+",b:"+b) ;//10,20 a = b ; //形参改变 b = a+ b ; System.out.println("a:"+a+",b:"+b) ;//20,40 } }
/**
*
* 如果形式参数是引用数据类型,(数组,类,接口),他们作为形式参数,
* 形式参数的改变会直接影响实际参数,他们都是空间地址值传递
*
* 看程序,写结果
*/
public class Test2 { public static void main(String[] args) { //创建一个数组,静态初始化 int[] arr = {1,2,3,4,5} ; System.out.println(arr[1]) ; //2 change(arr) ;//实际参数传递----数组对象----new 东西 空间地址值 System.out.println(arr[1]) ;//4 } //形式参数是引用数据类型,数组 public static void change(int[] arr) { //数组,引用数据类型 ---形式参数是数组类型--- //遍历数组 for(int x = 0 ; x < arr.length ; x ++){ if(arr[x] % 2== 0){ arr[x] *=2 ; } } } }
/**
* 如果形式参数是引用数据类型,(数组,类,接口),他们作为形式参数,
* 形式参数的改变会直接影响实际参数,他们都是空间地址值传递
*
* 但是,
*
* String作为引用数据类型,是一种特殊的引用类型,
* 它作为形式参数的效果和基本类型是一致的,
* 形参的改变不会影响实际参数
*
* (因为String是常量)
* String str = "abc" ;
*/
public class Test3 { public static void main(String[] args) { //定义一个字符串 String str = "hello" ; System.out.println("str:"+str);//str:hello change(str) ; System.out.println("---------------------") ; System.out.println("str:"+str);//str:hello } //change方法 public static void change(String str) { //形式参数是String类型 System.out.println(str) ;//hello str += "高圆圆" ; System.out.println(str) ;//hello高圆圆 } }
/**
*形式参数问题:
* 后面面向对象都研究的是引用数据类型(重点)
* String,是特殊的引用类型,作为形式参数,形参的改变不影响实际参数
* 需要String,就给一个String类型
* 如果数组,---实际参数传递---传递的数组对象!!
*
* 如果当前形式参数是类(引用数据类型),调用方法的时候,实际参数需要传递的是当前类的具体对象
* 类名 对象名 = new 类名() ; 具体的对象名---就是那个空间地址值传递
*///定义一个学生类 class Student{ //成员方法 public void study(){ System.out.println("Good Good Study ,Day Day Up!!!"); } } //StudentDemo类 class StudentDemo{ //成员方法 public void method(Student student){//形式参数Student类型,引用类型 student.study() ;//什么才能访问学生类的study方法呢? //学生对象才能访问study方法呀!! //实际参数需要创建Student类对象才能访问study() //下面的实际参数就是s---代表学生对象 //s.study() ; } } //测试类 public class StudentTest { public static void main(String[] args) { //需求:调用StudentDemo类中的method方法?如何访问呢? //1)创建StudentDemo类对象 StudentDemo studentDemo = new StudentDemo() ; //一看到,当前method方法中有一个Student类型,所以需要创建Student类的对象 Student s = new Student() ; studentDemo.method(s);//实际参数,形式参数是Student类型 } }
/**
* 看程序,写结果
*/class ClassA{ //ClassA类型 int value; //成员变量---堆内存中的---跟当前类的对象有关系 默认值就是0 } public class TestClassA{ public static void main(String args[]){ int value = 10;//局部变量 System.out.println(value) ; //10 changeInt(value); System.out.println(value);//10 System.out.println("=================================="); ClassA ca = new ClassA(); // 创建一个类的对象,系统对当前类的成员变量系统默认初始化 ca.value = 10; //显示初始化给直接赋值了10 ,使用当前ca对象(空间地址值引用) System.out.println(ca.value) ; //10 changeObject(ca);//对象:空间地址值引用 System.out.println(ca.value);//11 } //形式参数是基本类型,形参的改变不影响实际参数,而且方法调用完毕,就消失了! //四类八种:基本数据类型:jvm不需要加载的,但是引用类型需要加载类的! public static void changeInt(int value){//10 //形式参数:基本数据类型,形参的改变不会实际参数 value++; //11 System.out.println(value); } //当前这个方法调用完毕,里面是对象(空间地址值),不会立即消失,等待垃圾回收掉的 public static void changeObject(ClassA ca){//形式参数是一个引用类型,调用 //这个方法的时候,里面传递当前ClassA的类对象 --->ca 对象 ca.value++; //10++ = 11,引用类型,形式参数的改变直接影响实际参数(String除外!) } }
/**
* 学生事物
* 属性:姓名,年龄,性别--->全部加入 private修饰
* 行为:学习(),玩游戏()
*
* 在当前StudentTest类中进行测试
*/
public class Student { //成员变量:私有化 private String name ; //姓名 系统默认初始化---然后通过setXXX赋值了 null private int age ; //年龄 0 private String gender ;//性别 null //提供对外的公共访问方法 //成员方法:去掉static //一会需要赋值; setXXX方法 public void setName(String n){ //"高圆圆" name = n ; //"高圆圆" } //一会获取成员变量的值 getXXX方法 public String getName(){ return name ;//"高圆圆" } //给年龄赋值 public void setAge(int a){//42 age = a ; //42 } //获取年龄值 public int getAge(){ return age ;//42 } //给性别赋值 public void setGender(String g){ gender = g ; //局部变量g 赋值给成员变量 "女" } //获取性别的值 public String getGender(){ return gender ; //"女" } //学习(),玩游戏() public void study(){ System.out.println("我们在学习JavaSE..."); } public void playGame(String gameName){ System.out.println("学习到周末,可以玩"+gameName+"放松一下"); } }/**
*
* 封装:
* 将一个事物中的所有属性私有化private,保证其安全性(属性隐藏了),
*提供对外的公共访问SetXXX()/getXXX()访问
* 将昨天的学生事物
* 属性:姓名,年龄,性别
* 行为:学习(),玩游戏()
* 在当前StudentTest类中进行测试
*
* 定义出学生类
*///测试类 public class StudentTest { //就是模拟数据---以后的数据都是从 mysql(市面上用的比较多的)数据库中获取的 public static void main(String[] args) { //测试Student类 //类名 对象名 = new 类名() ; Student s = new Student() ; //现在所有属性已经私有化 // s.name = "高圆圆" ; //s.age = 20 ; // s.gender = "女" ; // System.out.println(s.name+"---"+s.age+"---"+s.gender); //刚才手动给出了姓名,年龄,性别的setXXX()/getXXX()方法 //所以现在测试 //setXXX s.setName("高圆圆") ; s.setAge(42) ; s.setGender("女") ; //输出 :获取值getXXX System.out.println("学生的姓名是"+s.getName()+",年龄是:"+s.getAge()+",性别是:"+s.getGender()); //调用其他的成员方法 s.study(); s.playGame("战地5"); } }
/**
*
* 匿名对象:
* 没有名字的对象!
* 通用的格式:类名 对象名 = new 类名() ;有名字的对象
* Student s = new Student() ;//前提有一个学生Student
* s----就是对象的对象名
*
* 匿名对象的格式:
* new 类名() ; 不需要在栈内存开辟空间,
* 直接堆内存申请空间
* 匿名的好处:
* 1)在实际开发中,匿名对象不要多次,
* 使用一次即可,使用完毕之后,立即就被垃圾回收器回收了
* (因为没有栈内存变量指向堆内存地址)
* 一般情况:移动端:Android(基于JavaSE) 搞app,
* 考虑内存问题
* 我们以后---B/S结构 大型网站(PC端多一些),
* 类名 对象名 = new 类名() ;还是传统方式
* 2)匿名对象可以作为参数传递
* 3)匿名对象 从内存角度考虑,节省内存!
*///老师类 class Teacher{ //成员方法 public void love(){ System.out.println("爱生活,爱Java,爱高圆圆!!"); } } //定义TeacherDemo类 class TeacherDemo{ //成员方法 public void function(Teacher t){//形式参数是一个引用类型---老师类 t.love() ; //Teacher teacher = new Teacher() ;teacher是实际参数 //teacher.love() ; } } //测试类 public class NoNameDemo { public static void main(String[] args) { //要访问TeacherDemo类中的function方法? ,而且实际参数应该怎么传递 //1)创建一个TeacherDemo类对象 TeacherDemo td = new TeacherDemo() ; //观察:上面的function方法的形式参数是一个Teacher类型,需要传递实际参数:是Teacher类对象 Teacher teacher = new Teacher() ;//空间地址值 td.function(teacher) ; System.out.println("----------------------------------------"); //使用匿名对象操作: //匿名对象的格式是什么: new 类名() ; //要访问TeacherDemo类中的function方法? ,而且实际参数应该怎么传递 //1)创建一个TeacherDemo类对象 TeacherDemo td2 = new TeacherDemo() ; td2.function(new Teacher()); System.out.println("----------------------------------------"); //继续优化: 要访问TeacherDemo类中的function方法? ,而且实际参数应该怎么传递 //链式编程(仅仅是自己玩一下可以,实际开发中,尽量明细步骤来!) new TeacherDemo().function(new Teacher()); } }
/**
* 商品类
*/public class Product { /** * 成员变量:属性私有化! * 商品的名称 * 商品市场价格 * 商品商城价格 * 商品的描述 * 商品的是否下架 (int类型:0表示下架 1:表示未下架) */ private String productName ;// 商品名称 private double market_price ; //市场价格 private double shop_price ; //商城价格 private String productDesc ; //商品描述 private int productFlag ; //(int类型:0表示下架 1:表示未下架) //... 50个属性---->写 100个方法 工具----提高开发效率! //快捷键:alt+ins键(有的电脑笔记本:需要安fn键)--->选择getter and setter方法 //--->选择 ctrl+A 全选---回车即可 //生成公共的访问方法 //获取商品的名称 public String getProductName() { return productName ; //隐藏this.productName } //给商品名称赋值 public void setProductName(String productName) { this.productName = productName; } //获取市场价格 public double getMarket_price() { return market_price; } //给市场价格赋值 public void setMarket_price(double market_price) { this.market_price = market_price; } //获取商城价格 public double getShop_price() { return shop_price; } //赋值商城价格 public void setShop_price(double shop_price) { this.shop_price = shop_price; } //获取商品描述信息 public String getProductDesc() { return productDesc; } //赋值商品描述信息 public void setProductDesc(String productDesc) { this.productDesc = productDesc; } //获取商品的状态 public int getProductFlag() { return productFlag; //get方法的时候,此处隐藏this } //赋值商品的状态 public void setProductFlag(int productFlag) { this.productFlag = productFlag; } // 使用手机商品玩游戏 //使用电脑商品可以看电影.. public void playGame(){ System.out.println("可以使用当前的"+productName+"->玩游戏"); } public void watchMv(){ System.out.println("可以使用"+productName+"->看电影..."); } }/**
*
* 现在有一个商品事物
* 属性:
* 商品的名称
* 商品市场价格
* 商品商城价格
* 商品的描述
* 商品的是否下架 (int类型:0表示下架 1:表示未下架)
* ...
* ...
*
* 行为:
* 使用手机商品玩游戏
* 使用电脑商品可以看电影..
*
* 定义商品类... Product/Goods
* 属性私有化
* 提供对外的公共的访问方法.....
*///商品的测试类 public class ProductTest { public static void main(String[] args) { //测试商品类 Product product = new Product() ; //setXXX()方法赋值-------明天说构造方法(另一种赋值方式) //赋值 product.setProductName("华为mate40Pro") ; product.setMarket_price(6799.0); product.setShop_price(6599.99); product.setProductDesc("为照相而生"); product.setProductFlag(1); //表示未下架 System.out.println("商品的名称是:"+product.getProductName()+ ",它的市场价格是:"+product.getMarket_price()+",商城价格是:"+ product.getShop_price()+",商品的状态是:"+product.getProductFlag()); product.playGame() ; product.watchMv() ; } }/**
* 手机类
* 品牌
* 价格
* 颜色
* 机身内存
*
* 加入封装思想:加入私有修饰,提供对外的公共访问方法
*
* 其他的成员方法
* 玩游戏
* 发短信
* 打电话...
*/public class Phone { //成员变量 private String brand ; private int price ; private char color ;//字符类型 private String memory ; //提供setXXX()/getXXX()方法 //alt+ins(有的需要按fn,有的不需要) public String getBrand() { return brand; } public void setBrand(String brand) { this.brand = brand; } public int getPrice() { return price; } public void setPrice(int price) { this.price = price; } public char getColor() { return color; } public void setColor(char color) { this.color = color; } public String getMemory() { return memory; } public void setMemory(String memory) { this.memory = memory; } //打游戏 public void playGame(String gameName){ System.out.println("学习困了,玩一会"+gameName); } //发短信 public String sendMsg(String toName){ return "给"+toName+"发短信" ; } }/**
* 手机类--改造---加入封装思想(属性私有化,对外提供公共访问方法)
*
*/public class PhoneTest { public static void main(String[] args) { //创建对象 Phone phone = new Phone(); //new 类名() ;后面直接alt+enter键--回车即可!(推荐) //Phone phone = new Phone();// new 类名().var --->回车即可补全代码 //setXXX()赋值 phone.setBrand("华为mate40pro"); phone.setPrice(16999); phone.setColor('绿'); phone.setMemory("256G"); System.out.println("手机品牌是:"+phone.getBrand()+",价格位:"+phone.getPrice()+ ",手机颜色为:"+phone.getColor()+"以及内存大小是:"+phone.getMemory()); phone.playGame("CSGo"); String str = phone.sendMsg("高圆圆");//alt+enter键-->回车:代码提示/补全代码/导包...(神键) System.out.println(str); } }
/**
* 创建一个Address 类，描述如下：
* * (属性私有化,提供对外公共访问方法:封装改进)
* *
* * 该类有两个属性，
* * 1)String 类型的address，表示地址；2)String 类型
* * 的zipCode，表示邮编。
* * 2)定义成员方法：show方法，显示 address和邮信息
* * 例如:
* * 地址是: xxx
* * 邮编是：xxx
* 2）定义AddressTest测试类，
* 给成员变量赋值和测试成员方法
*
* 改包名/类名---都可以通过shift+f6改名字
*///地址类 public class Address { private String address ; //详细地址 private String zipCode ; //地址的邮编 //对外的公共的访问方法Setxxx()/getXXX() public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } public String getZipCode() { return zipCode; } public void setZipCode(String zipCode) { this.zipCode = zipCode; } public void show(){ System.out.println("当前详细地址是:"+address+",邮编是:"+zipCode); } } //测试类 public class AddressTest { public static void main(String[] args) { //创建Address类对象 Address address = new Address(); address.setAddress("西安市高新区高新六路南窑国际") ; address.setZipCode("66666"); address.show() ; } }
69
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
