第八章:面向对象课堂笔记与部分习题

一、面向对象与面向对象过程：
面向对象特征：封装 、继承、 多态。
面向过程：执行者；
面向对象：指挥者；
面向过程是最基本的，其次才有面向对象。宏观之下不可能只有面向对象。

类 - 对象:
类的定义：就是具有相同属性和行为的一些对象的统称、集合。
实体类：一般而言，把描述事物的类，称之为实体类。
工具类： Arrays、Math、System、
1）类描述事物时候，通常只描述属性、行为。
2）类中只能定义，不能写执行语句，执行语句只能在函数里面写；
//eclipse中只能有一个public类
类对于事物的描述只看两个方面：
属性： 可用变量表示：成员变量
行为：可用函数表示 成员函数
如何创建一个类？
先分析，该事物中‘’
1.有哪些成员变量（对象的特有属性）（最好全部写private）
2.有哪些成员函数（函数是否需要私有化（private），主要看该函数的功能是否需要向外界暴露）
创建对象的同时，需不需要直接给对象赋值？
如果需要，则定义相应的构造函数。
此时，若后期成员变量的值需要修改的话，需要setter getter 一般情况，最好写上。

对象：某一个具体的事物、实例、实体。
创建对象：person p=new person（）；储存在堆里；
因为对象在堆里创建的，所以有默认初始化；
int：0
double ：0.0
boolean： false
引用类型：null
成员变量的值：默认初始化—显示初始化----针对性初始化

创建类和对象课堂例子：
class Person1{
private String name;//姓名；私有化
private int age;//年龄
private String sex=“man”;//提前定义好的，显示初始化；
//setter getter 用来修改private形式下的属性值;
//成员函数
void speak(){
System.out.println(name+":"+sex+":"+age);
}
public String getName() {
return name;
}

public void setName(String name) {//修改私有属性name
if(name==“旺财”)
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {//修改私有属性age
if(age>=0){
this.age = age;
}
}

public String getSex() {
return sex;
}

public void setSex(String sex) {//修改私有属性sex
if(sex==“woman”)
this.sex = sex;
}
}

public class DemoDay1_1 {
public static void main(String[] args) {
Person1 p=new Person1();//创建对象，储存在堆里。
//调用对象的属性；
System.out.println(p.getAge());//0
System.out.println(p.getName());//null
System.out.println(p.getSex());//women
//修改对象的属性值；
//p.age=10;共有化直接修改
p.setAge(10);//私有化需要get set 函数修改
//p.name=“旺财”;
p.setName(“旺财”);
//p.sex=“women”;
p.setSex(“woman”);
p.speak();//旺财?10
}
}
总结：
setter getter用来修改私有属性的值，调用时候也应该写成p.setAge() p.getAge()

private：为了不能让外界直接访问对象的内部属性；成员变量一般写成私有的。

二、//成员变量与局部变量
当成员函数试图访问一个变量时，先看当前函数的内存空间中有没有该变量
有的话，就近 没有，就去指向（this.）的对象中找。
重命名的情况下，如何区分局部变量和成员变量: this

//成员变量和局部变量有何区别？
//1.存储位置:
成员变量存储在堆内存中所属对象的空间里
局部变量存在于栈内存中所属函数的空间里
2.生命周期：
成员变量随着对象的创建而存在，即有对象才有成员变量
局部变量随着函数的进栈而存在，随着函数的弹栈而消失
3.初始化：
成员变量有针对初始化
局部变量只能在初始化之后 被调用
4.访问范围:
成员变量一般而言全局访问
局部变量的作用域只存在当前函数空间

三、针对性初始化 构造函数相关
构造函数定义：有些对象在创建之时就有一些属性的赋值--------构造函数。
1.与类名相同
2.没有返回值类型
3.有修饰符
4.是一个函数、参数列表、函数体
构造函数和一般函数的区别：
1) 构造函数只有在创建对象的时候调用一次
一般函数在对象创建后，可以调用很多次
2) 构造函数没有返回值，但有return。
构造函数能调用一般函数;
一般函数不能调用构造函数;

public class demo3 {
public static void main(String[] args) {
//但凡创建对象 必须进行构造函数的调用
//在没有定义任何构造函数的时候，会有一个无参的构造函数，隐藏的
//如果一旦在类中定义了构造函数，则隐藏的无参构造函数失效
Dog1 d1=new Dog1();
d1.speak(); //运行结果：null 0 null
Dog1 d2=new Dog1(“小强”) ;
d2.speak(); //运行结果：小强 0 null
Dog1 d3=new Dog1(“小明”,10,“哈士奇”) ;
d3.speak()； //运行结果：小明 10 哈士奇
}
}
class Dog1{
//属性
String name;
int age;
String type;

//无参构造函数
public Dog1(){
//构造函数在调用构造函数时，只能在第一行
this(null);
}
public Dog1(String name){ //在创建Dog1的时候，给Dog1起了名字。
this.name=name;
}
public Dog1(String name,int age,String type){ //在创建Dog1的时候，给Dog1赋值了名字、年龄、品种。
this.name=name;
this.age=age;
this.type=type;
//return
}
public void speak(){
System.out.println(name+","+age+","+type);
//return
}
}
重点习题：
1.给风扇设置颜色，速度，开关等属性，最后创建对象，验证结果。

public class test8_3风扇 {
public static void main(String[] args) {
fan fan1=new fan();
fan1.setSpeed(fan1.fast);
fan1.setRadius(10);
fan1.setColor(“yellow”);
fan1.setOn(true);
System.out.println(fan1.toString());
fan fan2=new fan();
fan1.setSpeed(fan1.medium);
fan2.setRadius(5);
fan1.setColor(“blue”);
fan1.setOn(false);
System.out.println(fan2.toString());

}

}
class fan{
public static final int slow=1;
public static final int medium=2;
public static final int fast=3;
private int speed=slow;
private boolean on=false;
private double radius=5;
private String color=“blue”;
public int getSpeed() {
return speed;
}
public void setSpeed(int speed) {
this.speed = speed;
}
public boolean isOn() {
return on;
}
public void setOn(boolean on) {
this.on = on;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public fan(){
}
public String toString(){
if(isOn()){
return speed+color+radius;
}else{
return “fan is off”+":"+color+radius;

	}	
}

}

2.计算从1970年1月1日到当前时间经过了多少小时 多少分钟 多少秒。分别以当前时间，传入的毫秒，传入的小时，分钟，秒；传入的流逝时间；计算。

public class test8_4时间类 {
public static void main(String[] args) {
Time t1=new Time();
System.out.println(t1.getHour());
System.out.println(t1.getMinute());
System.out.println(t1.getSecond());
Time t2=new Time(1000000);
System.out.println(t2.getHour());
System.out.println(t2.getMinute());
System.out.println(t2.getSecond());
}
}
class Time{
private long hour;
private long minute;
private long second;
private long totalmillis;
public Time(){//以当前时间计算小时 分钟 秒
totalmillis=System.currentTimeMillis();
HuanSuan(totalmillis);
}
public Time(long millis){//以传入的毫秒值计算
totalmillis=millis;
HuanSuan(totalmillis);
}
public Time(long hour,long minute,long second){
//以传入的小时 分钟 秒计算
this.hour=hour;
this.minute=minute;
this.second=second;
}
public void setTime(long elapseTime){
totalmillis=totalmillis+elapseTime;
HuanSuan(totalmillis);
}
public void HuanSuan(long millis){
this.hour=millis/1000/60/60;
this.minute=millis/1000/60-hour60;
this.second=millis/1000-hour3600-minute60;
totalmillis=hour60601000+minute601000+second*1000;
}
public long getHour() {
return hour;
}
public long getMinute() {
return minute;
}
public long getSecond() {
return second;
}
}
3.判断点和圆、圆和圆的位置关系：

public class test8_5圆 {
public static void main(String[] args) {
Circle c1=new Circle(0,0,4);
Circle c2=new Circle(2,2,2);
System.out.println(c1.contains(c2));
}
}
class point{
private double x;
private double y;
private double radius;
public point(){
this(0,0);
}
public point(double x,double y){
this.x=x;
this.y=y;
}
public double getDistance(double x,double y){
return Math.sqrt(Math.pow(this.x-x, 2)+Math.pow(this.y-y, 2));
}
public double getDistance(point p){
return Math.sqrt(Math.pow(this.x-p.x, 2)+Math.pow(this.y-p.y, 2));
}
public double getX(double x){
return x;
}
public void setX(double x){
this.x=x;
}
public double getY(double y){
return y;
}
public void setY(double y){
this.y=y;
}
}
class Circle{
private point o;
private double radius;
public point getO() {
return o;
}
public void setO(point o) {
this.o = o;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
public Circle(){//无参构造函数
this(0,0,1);
//o=new point();
//radius=1;
}
public Circle(double x,double y,double oradius){
o=new point(x,y);
this.radius=radius;
}
public boolean contains(double x,double y){ //点在园内
point p=new point(x,y);
return o.getDistance(x, y)<=radius;
}
public boolean contains(Circle other){//圆在圆内
return this.radius-other.radius>=o.getDistance(other.o);
}
public boolean overlaps(Circle other){//两圆相交或重叠
double distance=o.getDistance(other.o);
//大于两半径之差 且 小于两半径之和
return distance>this.radius-other.radius && distance<this.radius+other.radius;

}

}
4.吃鸡游戏： ：模拟玩家将弹夹装入子弹，再将弹夹装入枪，玩家向敌人开枪，敌人掉血。
主要思路和变量：
*************///
Player 玩家
hp 血量
name 名字
Gun 枪

putBulletIntoClip(Bullet bullet)  //子弹装进弹夹里
putClipIntoGun(Clip)	//将弹夹装进枪里
takeGun (Gun gun)  		//人拿起枪
fire(Player enemy) 		//向目标开火
reduce(int execution) 	//将弹夹装进枪里

Gun 枪
Clip clip 弹夹
takeClip(clip clip)

Clip 弹夹
bullet[]bullets //一组子弹
pushBullet(Bullet bullet)
Bullet 子弹
execution 伤害值
injury(player)
///********************///
代码：
public abstract class test8_6 {
public static void main(String[] args) {
player p1=new player(“小明”,100);
player p2=new player(“小芳”,80);
p1.info();
p2.info();
Clip clip=new Clip(40);
clip.info();
for(int i=1;i<=10;i++){
Bullet bullet=new Bullet();
p1.putBulletIntoClip(clip,bullet);
}
clip.info();
Gun gun=new Gun();
gun.info();
p1.takeGun(gun);
p1.info();
p1.putClipIntoGun(clip);
gun.info();
p1.fire(p2);
p1.fire(p2);
p1.fire(p2);
p1.fire(p2);
p2.info();

}

}
class player{
int HP;
String name;
Gun gun;
public player(String name,int HP){
this.name=name;
this.HP=HP;
gun=null;
}
public void subHP(int execution){
HP-=execution;
}
public void putBulletIntoClip(Clip clip,Bullet bullet){
clip.pushBullet(bullet);
}
public void putClipIntoGun(Clip clip){
if(gun!=null){
gun.takeClip(clip);
}else{
System.out.println(name+“没枪，无法装弹夹”);
}
}
public void takeGun(Gun gun){
if(this.gunnull){
System.out.println(name+“持枪”);
this.gun=gun;
}else{
System.out.println(name+“换枪”);
this.gun=gun;
}
}
public void fire(player enemy){
System.out.println(this.name+""+enemy.name+"");
gun.shoot(enemy);
}
public void info(){
System.out.println(""+name);
System.out.println(""+HP);
System.out.println(""+(gunnull?“无枪”:“持枪”));
}
}
class Gun{
Clip clip;
public Gun(){
this(null);
}
public Gun(Clip clip) {
this.clip=clip;
}
public void takeClip(Clip clip){
if(clipnull){
System.out.println(“成功装上弹夹”);
this.clip=clip;
}else{
System.out.println(“成功换掉弹夹”);
this.clip=clip;
}
}
public void shoot(player enemy){
Bullet bullet=clip.popBullet();
if(bulletnull){
System.out.println(“子弹已经用尽，放了个空枪”);
}else{
bullet.injury(enemy);
}
}
public void info(){
System.out.println(“弹夹”+(clipnull?“无”:“有”));
}
}
class Clip{
Bullet[] bullets;
int size;
public Clip(){
this(30);
}
public Clip(int size){
this.size=size;
bullets=new Bullet[0];
}
public void pushBullet(Bullet bullet){
if(bullets.length<size){
bullets=Arrays.copyOf(bullets, bullets.length+1);
bullets[bullets.length-1]=bullet;
}else{
System.out.println(“弹夹已满，无法继续装入子弹”);
}
}
public Bullet popBullet(){
if(bullets.length0){
System.out.println(“弹夹已经空，请装弹”);
return null;
}else{
Bullet bullet=bullets[bullets.length-1];
bullets=Arrays.copyOf(bullets, bullets.length-1);
return bullet;
}
}
public void info(){
System.out.println(“子弹容量”+bullets.length+"/"+size);
}
}
class Bullet{
int execution; //伤害值
public Bullet(){
this(10);
}
public Bullet(int execution){
this.execution=execution;
}
public void injury(player enemy){
enemy.subHP(execution);
}
}
静态：
静态变量和成员变量：
静态变量：所有对象的共有属性(共享的)，其生命周期大于对象；不可修改。
静态函数：只要该函数不直接调用成员变量或成员函数，则可以静态；
静态变量与成员变量的区别;
生命周期：
成员变量：随着对象的创建而存在，随着对象的销毁而消失；
静态变量：随着类的加载而存在，随着类的消失而消失；
调用方式：
成员变量：只能通过对象实例化后进行调用
静态变量：可以直接通过类调用 也可以通过对象调用
别名：
成员变量：实例变量 对象特有属性
静态变量：类变量 对象共有属性
数据存储位置：
成员变量：储存在堆内存中，对象的所属空间里；
静态变量: 存储在方法区中的静态方法区里；
方法区：是内存中临时储存应用程序代码(二进制)的地方
*
public class JingTaiDemo {
int a=5;//成员变量
public static void main(String[] args) {
//System.out.println(a); 直接访问不了
JingTaiDemo d1=new JingTaiDemo();
System.out.println(d1.a);//通过对象实例化后就可以成功访问；
Chinese c1=new Chinese(“小红”,10);
c1.show();
Chinese c2=new Chinese(“小明”,12);
System.out.println(c1.COUNTRY);//China
System.out.println(c2.COUNTRY);//China
//输出结果为China;因为COUNTRY为对象共有属性
//所以Chinese类中所有的对象都为China;
}
}
class Chinese{
public static final String COUNTRY=“China”;//静态变量
//public代表可以全局访问；static代表该变量为对象共有的；
//final代表不可修改；需要大写；
int age;
String name;
Chinese(String name,int age){
this.name=name;
this.age=age;
}
void show(){
System.out.println(name+"："+age+":"+COUNTRY);
}
}
对象的创建过程：
/*
javac 将原代码进行编译 生成.class文件：JingTaidemo.class 和Chinese.class
Java JingTaiDemo.class 将JingTaidemo.class(Chinese.class)文件加载进JVM里；
将.class文件分为静态区 非静态区
JVM会在静态方法区里寻找主函数！
1.主函数进栈，开始执行代码:::
2.开辟空间 分配地址 对对象的成员变量进行默认初始化；
3.再对成员变量进行显示初始化；
4.相应的构造函数进栈 (this.)进行针对性初始化；
5.构造函数弹栈，将地址赋给函数中的局部变量；
对象在调用变量时，先在堆里找，再去静态方法区里找；
成员函数在访问变量时，先在函数中找局部变量，再找堆，后再静态方法区里找；
*/