面向对象
1.面向对象的思想
面向对象是基于面向过程的！
面向过程：
从需求到分析，从业务逻辑到结果输出，整个过程都是自己完成（什么活都是自己亲力亲为，执 行者）
需求: 键盘录入三个数据,使用功能改进,求三个数据中最大值!
1)分析:导包
2）创建键盘录入对象Scanner
3）提示并录入数据
4)定义一个功能(方法)
4.1)分析:明确返回值类型/明确参数类型以及参数个数
4.2)方法中业务逻辑:if…else… /三元运算符操作
5)调用方法
6)输出结果
面向对象的思想特点：
1）让复杂的事情简单化，
2）更符合生活中的思想行为习惯，
3）让我们从执行者变为指挥者（角色发生变化）
面向对象的设计原则：
在不断的创建对象，使用对象，指挥对象做事情，
面向对象的三大特征：
1）封装
2）继承
3）多态
1.类与事物的关系；
事物：是能够描述现实世界真实存在的泛指的东西，
EX； 学生------->学生事物
java中，最基本的单位是类：class
类：是能够描述一组事物的行为和属性的集合！
学生事物
属性：姓名，身高，年龄，性别
行为: 学习，吃饭，睡觉，
使用Java代码的方式描述上面的学生事物:
定义一个类:学生类 class Student{}
成员变量(在类中,方法外定义):name,age,stuId,gender,hight…
成员方法:(去掉static关键字): 之前的方法怎么定义,现在还怎么定义,只是去掉static即可!
study(),eat(),sleep(),playGame()…
2.类和对象：
类：一组事物的属性和行为的集合！对应的真实存在的事物（泛指）
对象：描述的应该是真实事物中的具体的，比如：王冰冰，
代码实现：
创建对象
类名 对象名 = new 类名（）；
对象名.成员变量=赋值；
对象名.方法名（）；----------使用此方法
例
class Student{
//创建成员变量
String name;
int age;
String sex;
int hight;
//创建成员方法 去掉static
public void study(String learnName){
System.out.println("在学习"+learnName);
}
public void playGame(String gameName){
System.out.println("在玩"+gameName);
}
}
class StudentTest{
public static void main(String[] args){
//创建一个对象、
//类名 对象名=new 类名
Student s=new Student();
//给成员变量赋值
s.name="小明";
s.age=18;
s.sex="女";
s.hight=165;
//调用方法
s.study("javaEE");
s.playGame("LOL");
System.out.println(s.name+s.age+s.sex+s.hight);
}
}
3.局部变量和成员变量的区别
1）代码书写位置不同
局部变量：在方法定义中或者是方法声明上的变量
成员变量：在类中方法外定义
2）内存中位置不同
局部变量：在栈内存中
成员变量：在堆内存中
3）生命周期不同
局部变量: 随着方法的调用而存在，随着方法调用的结束而结束（使用完毕，立即消失）
成员变量：随着类的加载而存在，随着类的加载完毕，等待垃圾回收器自动回收而消失！
（对象创建完毕，对象可能被继续使用，因此不会立即消失）
4）初始化不同
局部变量：必须赋值才可以使用，定义时必须在使用前初始化，要么直接初始化，不能没有初始化值！
成员变量：随着类的加载而存在，存在系统默认初始化，可以不直接赋值！
4.成员变量的定义时机
如果当前这个变量可以描述真实事物的属性，这个时候将变量定义为成员变量。
而如果这个变量不能够体现出真实事物的属性，那么定义为局部变量。
5.引用类型作为参数传递_类
/*
基本类型作为形式参数传递,形式参数的改变不会影响实际参数!
引用类型在作为参数传递,形式参数的改变会直接影响实际参数!(除了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) ; //实际参数是什么?
}
}
6.匿名对象
/*
匿名对象:
没有名字的对象!
格式:
new 类名() ;
特点:
1)开发中使用一次即可
2)使用完毕,立即被回收,可以结束内存空间!
这种写法针对:移动端: Android(考虑内存问题)
3)作为参数传递
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()) ;
}
}
2.封装
1.封装的定义；
将一个事物的属性，私有化（对外隐藏），外界不能直接访问（保证了数据的安全性），需要提供对外的公共访问来访问成员变量！
private： 私有的，外界无法访问，只能在本类中访问；
/*
将学生类进行改造
将name,age属性私有化
只能在本类访问,外界要访问,需要通过公共方法访问
赋值/获取值 setxxx()getxxx() (成员方法)
*/
//定义一个学生类
class Student{
//成员变量:name,age 私有化
private String name ;
private int age ;
//提供对外的公共访问方法: 去掉static
//给学生姓名赋值
public void setName(String n){ //"高圆圆"
name = n ;
}
//给学生年龄赋值
public void setAge(int a){ // 30
age = a ;
}
//获取学生的姓名
public String getName(){
return name ;
}
//获取学生的年龄
public int getAge(){
return age ;
}
//成员方法:学习
public void study(){
System.out.println("学习JavaSE_面向对象部分") ;
}
}
//测试类
class StudentTest{
public static void main(String[] args){
//创建一个学生类对象
Student s = new Student() ;
System.out.println(s.getName()+"---"+s.getAge()) ;
//s.name = "高圆圆" ;
//s.age = 30 ;
//公共访问:setXXX()赋值
s.setName("高圆圆") ;
s.setAge(30) ;
//公共访问方法:setXXX()获取值
System.out.println(s.getName()+"---"+s.getAge()) ;
}
}
2335
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
