JavaSE学习总结第07天_面向对象2
07.01 成员变量和局部变量的区别
1.在类中的位置不同
成员变量 类中方法外
局部变量 方法内或者方法声明上
2.在内存中的位置不同
成员变量 堆内存
局部变量 栈内存
3.生命周期不同
成员变量 随着对象的存在而存在，随着对象的消失而消失
局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
4.初始化值不同
成员变量 有默认的初始化值
局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。
07.02 方法的形式参数是类名的调用
例:
class Demo
{
public static void main(String[] args)
{
//创建学生对象
Student s = new Student();
StudentDemo sd = new StudentDemo();
sd.method(s);
}
}
class StudentDemo
{
//形式参数是引用类型
public void method(Student s)
{
s.show();
}
}
class Student
{
public void show()
{
System.out.println("学生爱学习");
}
}
07.03 匿名对象的概述和应用
匿名对象:就是没有名字的对象。是对象的一种简化表示形式
匿名对象的两种使用情况:
1.对象调用方法仅仅一次的时候
2.作为实际参数传递
例:
class Demo
{
public static void main(String[] args)
{
//匿名对象调用方法
new Student().show();
}
}
class Student
{
public void show()
{
System.out.println("学生爱学习");
}
}
匿名对象调用完毕就是垃圾，垃圾回收器会在适当的时间回收，提高内存的使用效率
07.04 封装的概述
封装概述:是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
例:
class Student
{
String name;
//将age私有，只能在Student类中访问
private int age; //提供对外访问的方法获取age的值
public int getAge()
{
return age;
}
//提供对外访问的方法，并可以对传入的a的值进行判断，满足条件则赋值给age，不满足则不赋值
public void setAge(int a)
{
age = a;
}
public void show()
{
System.out.println("姓名:"+name+" "+"年龄:"+age);
}
}
07.05 封装的好处和设计原则
封装好处:
1.隐藏实现细节，提供公共的访问方式
2.提高了代码的复用性
3.提高安全性
封装原则:将不需要对外提供的内容都隐藏起来。把属性隐藏，提供公共方法对其访问。
07.06 private关键字的概述和特点
private关键字:是一个权限修饰符。可以修饰成员(成员变量和成员方法)，被private修饰的成员只在本类中才能访问。
private最常见的应用:
1.把成员变量用private修饰
2.提供对应的getXxx()/setXxx()方法
07.07 private的应用标准案例
class Demo
{
public static void main(String[] args)
{
Student s = new Student();
//给成员变量赋值
s.setName("小强");
s.setAge(25); System.out.println(s.getName()+":"+s.getAge());
}
}
class Student
{
private String name;
//将age私有，只能在Student类中访问
private int age; //提供对外访问的方法获取name的值
public String getName()
{
return name;
}
//提供对外访问的方法设置name的值
public void setName(String n)
{
name = n;
}
//提供对外访问的方法获取age的值
public int getAge()
{
return age;
}
//提供对外访问的方法设置age的值
public void setAge(int a)
{
age = a;
}
}
07.08 this关键字的概述和应用
this:代表所在类的对象引用
方法被哪个对象调用，this就代表那个对象
当局部变量隐藏成员变量时使用this
例:
class Student
{
private String name;
//将age私有，只能在Student类中访问
private int age; //提供对外访问的方法获取name的值
public String getName()
{
return name;
}
//提供对外访问的方法设置name的值
public void setName(String name)
{
this.name = name;
}
//提供对外访问的方法获取age的值
public int getAge()
{
return age;
}
//提供对外访问的方法设置age的值
public void setAge(int age)
{
this.age = age;
}
}
07.09 this关键字的内存图解
07.10 标准的手机类代码及其测试
class Demo
{
public static void main(String[] args)
{
Phone p = new Phone();
System.out.println("品牌:"+p.getBrand()+" 价格:"+p.getPrice()+" 颜色:"+p.getColor());
p.setBrand("小米");
p.setPrice(1999);
p.setColor("白色");
System.out.println("品牌:"+p.getBrand()+" 价格:"+p.getPrice()+" 颜色:"+p.getColor());
}
}
class Phone
{
private String brand;//品牌
private int price;//价格
private String color;//颜色 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 String getColor()
{
return color;
}
public void setColor(String color)
{
this.color = color;
}
}
运行结果:
品牌:null 价格:0 颜色:null
品牌:小米价格:1999 颜色:白色
07.11 构造方法概述和格式
构造方法作用概述:给对象的数据进行初始化
构造方法格式:
1.方法名与类名相同
2.没有返回值类型，连void都没有
3.没有具体的返回值
例:
07.12 构造方法的重载及注意事项
构造方法注意事项:
1.如果不提供构造方法，系统会给出默认构造方法
2.如果提供了构造方法，系统将不再提供
3.构造方法也是可以重载的
07.13 成员方法的分类及使用
方法具体划分:
根据返回值:1.有明确返回值方法 2.返回void类型的方法
根据形式参数:1.无参方法 2.带参方法
例:
class Demo
{
public static void main(String[] args)
{
Student s = new Student();
String str = s.getString();
System.out.println(str);
s.show();
s.method("小强");
}
}
class Student
{
private String name;
private int age;
//有明确返回值的无参方法
public String getString()
{
return "hello";
}
//返回void类型的无参方法
public void show()
{
System.out.println("show run");
}
//返回void类型的带参方法
public void method(String name)
{
System.out.println("name:"+name);
}
}
07.14 一个标准学生类的代码及测试
类的组成:
1.成员变量
2.构造方法[无参构造方法 / 带参构造方法]
3.成员方法[getXxx() / setXxx()]
给成员变量赋值的方式
1.无参构造方法 + setXxx()
2.带参构造方法
/*
学生类:
成员变量:name，age
构造方法:无参，带两个参
成员方法:getXxx()/setXxx()
show():输出该类的所有成员变量值 给成员变量赋值:
A:setXxx()方法
B:构造方法 输出成员变量值的方式:
A:通过getXxx()分别获取然后拼接
B:通过调用show()方法搞定
*/
//测试类
class Demo
{
public static void main(String[] args)
{
//方式1给成员变量赋值
//无参构造+setXxx()
Student s1 = new Student();
s1.setName("小明");
s1.setAge(27);
//输出值
System.out.println(s1.getName()+"---"+s1.getAge());
System.out.println("----------------------------"); //方式2给成员变量赋值
Student s2 = new Student("小强",30);
s2.show();
}
} class Student
{
//姓名
private String name;
//年龄
private int age; //构造方法
public Student()
{
} public Student(String name,int age)
{
this.name = name;
this.age = age;
} public String getName()
{
return name;
} public void setName(String name)
{
this.name = name;
} public int getAge()
{
return age;
} public void setAge(int age)
{
this.age = age;
} //输出所有的成员变量值
public void show()
{
System.out.println(name+"---"+age);
}
}
07.15 一个标准的手机的代码及测试
//测试类
class Demo
{
public static void main(String[] args)
{
//创建对象
Phone p = new Phone(); //给成员变量赋值
p.setBrand("小米");
p.setPrice(2299);
p.setColor("白色"); //获取值
System.out.println(p.getBrand()+"---"+p.getPrice()+"---"+p.getColor());
}
} //定义手机类
class Phone
{
//品牌
private String brand;
//价格
private int price;
//颜色
private String color; //无参构造方法
public Phone()
{
} //getXxx()和setXxx()方法
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 String getColor()
{
return color;
}
public void setColor(String color)
{
this.color = color;
}
}
07.16 创建对象做了哪些事情
Student s = new Student();在内存中做了哪些事情?
1.加载Student.class文件进内存
2.在栈内存为s开辟空间
3.在堆内存为学生对象开辟空间
4.对学生对象的成员变量进行默认初始化
5.对学生对象的成员变量进行显示初始化
6.通过构造方法对学生对象的成员变量赋值
7.学生对象初始化完毕，把对象地址赋值给s变量
07.17 什么时候定义成员变量
如果这个变量是用来描述这个类的信息的，那么，该变量就应该定义为成员变量。变量的范围越小越好，因为能及时的被回收。
07.18 长方形案例练习
定义一个长方形类,定义求周长和面积的方法，然后定义一个测试类Demo，进行测试。
/*
成员变量:长，宽
成员方法:
求周长:(长+宽)*2;
求面积:长*宽
*/
import java.util.Scanner;
class ChangFangXing
{
//长方形的长
private int length;
//长方形的宽
private int width; public ChangFangXing()
{
} //仅仅提供setXxx()即可
public void setLength(int length)
{
this.length = length;
} public void setWidth(int width)
{
this.width = width;
} //求周长
public int getZhouChang()
{
return (length + width) * 2;
} //求面积
public int getArea()
{
return length * width;
}
} //测试类
class Demo
{
public static void main(String[] args)
{
//创建键盘录入对象
Scanner sc = new Scanner(System.in); System.out.println("请输入长方形的长:");
int length = sc.nextInt();
System.out.println("请输入长方形的宽:");
int width = sc.nextInt(); //创建对象
ChangFangXing cfx = new ChangFangXing();
//先给成员变量赋值
cfx.setLength(length);
cfx.setWidth(width); System.out.println("周长是:"+cfx.getZhouChang());
System.out.println("面积是:"+cfx.getArea());
}
}
07.19 员工类案例练习
/*
成员变量:员工编号，姓名，年龄
构造方法:无参构造方法
成员方法:
getXxx()/setXxx();
show();
*/ class Employee
{
//员工编号
private String employeeId;
//姓名
private String name;
//年龄
private int age; //构造方法
public Employee()
{
} //getXxx()/setXxx()
public String getEmployeeId()
{
return employeeId;
} public void setEmployeeId(String employeeId)
{
this.employeeId = employeeId;
} public String getName()
{
return name;
} public void setName(String name)
{
this.name = name;
} public int getAge()
{
return age;
} public void setAge(int age)
{
this.age = age;
} //显示所有成员信息的方法
public void show()
{
System.out.println("员工编号:"+employeeId+" 姓名:"+name+" 年龄:"+age);
}
} //测试类
class Demo
{
public static void main(String[] args)
{
//创建对象
Employee e = new Employee(); //给成员变量赋值
e.setEmployeeId("ID8899");
e.setName("旺财");
e.setAge(18); //获取数据
//System.out.println(e.getEmployeeId()+"---"+e.getName()+"---"+e.getAge()); //使用show方法
e.show();
}
}
07.20 实现加减乘除并测试
import java.util.Scanner;
class MyMath
{
//加法功能
public int add(int a,int b)
{
return a + b;
} //减法功能
public int sub(int a,int b)
{
return a - b;
} //乘法功能
public int mul(int a,int b)
{
return a * b;
} //除法功能
public int div(int a,int b)
{
return a / b;
}
} //测试类
class Demo
{
public static void main(String[] args)
{
//创建键盘录入对象
Scanner sc = new Scanner(System.in); System.out.println("请输入第一个操作数:");
int num1 = sc.nextInt();
System.out.println("请输入第二个操作数:");
int num2 = sc.nextInt(); //创建MyMath对象，并使用
MyMath mm = new MyMath(); System.out.println(num1+"+"+num2+"="+mm.add(num1,num2));
System.out.println(num1+"-"+num2+"="+mm.sub(num1,num2));
System.out.println(num1+"*"+num2+"="+mm.mul(num1,num2));
System.out.println(num1+"/"+num2+"="+mm.div(num1,num2));
}
}
运行结果:
请输入第一个操作数:
8
请输入第二个操作数:
2
8+2=10
8-2=6
8*2=16
8/2=4
07.21 static关键字的引入
例:
class Person
{
String name;
//使用static修饰的数据称为对象的共享数据
static String country = "中国";
public void show()
{
System.out.println("姓名:"+name+" 国家:"+country);
}
} class Demo
{
public static void main(String[] args)
{
Person p1 = new Person();
p1.name = "小明";
p1.show(); Person p2 = new Person();
p2.name = "小红";
p2.country = "美国";
p2.show();
p1.show(); }
}
运行结果:
姓名:小明 国家:中国
姓名:小红 国家:美国
姓名:小明 国家:美国
07.22 static关键字的特点
1.static是一个修饰符，用于修饰成员(成员变量和成员函数)
2.static修饰的成员被所有的对象共享
3.static优先于对象存在，因为static成员随着类的加载就已经存在了
4.static修饰的成员可以被对象调用，也可以直接被类名调用，格式为：类名.静态成员
5.static修饰的数据是共享数据，对象中存储的是特有数据
07.23 static的内存图解
07.24 static的注意事项
1.在静态方法中是没有this关键字的
2.静态方法只能访问静态的成员变量和静态的成员方法
3.主函数是静态的，如果要在主函数中调用非静态成员可以创建一个对象来调用
07.25 静态变量和成员变量的区别
1.所属不同
静态变量属于类，所以也称为为类变量
成员变量属于对象，所以也称为实例变量(对象变量)
2.内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于堆内存
3.内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
4.调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用
07.26 main方法的格式详细解释
最新文章
- document.body.scrollTop
- CRM 2013 安装前系统和数据库的基础配置
- App开发到App Store上架，发布流程。
- codeforce 421D D. Bug in Code
- MySQL的字符编码体系（二）——传输数据编码
- maven,本地仓库和私服nexus的配置,以及eclipse载入maven
- 2016-05-I
- Poj1741-Tree(树分治)
- 使用yiic安装开发web应用和解决yiic不是内部命令
- mysql安装注意
- Linux中查看socket状态（转）
- Wireshark简单使用教程3——附视频
- php 10进制转62进制，可用于短网址生成
- Confluence 6 邮件队列
- Golang 数组和字符串之间的相互转换[]byte/string
- parfor slice
- 当activity改变时，我们如何处理它
- Python的多线程和多进程
- 洛谷P2296寻找道路
- WebDriver API 实例详解（四）