java第8天----封装性，继承，单例，

昨天知识总结

• 1.static
  • 成员变量和局部变量的区别
  • static修饰成员后的作用
  • static作用总结
• 2.构造方法
  • 构造方法的使用
  • this
• 3.匿名对象
• 4.注意点
• 5.静态代码块和构造代码块

封装性

• 封装性：（根据对属性的封装说明），把对成员变量的访问私有化，通过一个公共的方法间接的实现
• 好处：提高了代码的安全性，可读性，复用性
• 脏数据：在程序中出现的不合逻辑的数据
• 原因：直接将数据交给了成员变量
• 如何避免脏数据？
  • 1.不要将值赋值给成员变量----让成员变量不可见，将成员变量私有化
  • 2.通过方法间接的访问他，先过滤，后赋值
• 因为对所有的属性都要进行赋值和取值，系统在制定了一套默认的规则 -----get set方法
  • set—完成赋值
    • 构成：修饰词 返回值 方法名（参数列表）{方法体
      返回值
      }
    • 返回值：不需要返回值----这里写void
    • 方法名：set+对应成员变量的名字，成员变量的首字母大写
    • 参数列表：只有一个参数，参数的类型行与成员变量的类型一致，名字是成员变量的名字
    • 方法体：不需要返回值，我们可以写 this.成员变量 = 形参的名字
  • get—完成取值
    • 构成：修饰词 返回值 方法名（参数列表）{方法体
      返回值
      }
    • 修饰词：一般是public
    • 返回值：类型与成员变量一致
    • 方法名：get+对应成员变量的名字，成员变量的首字母大写
    • 参数列表：不需要参数
    • 快捷键
    • shift+alt+s

	public static void main(String[] args) {
		//开枪射击
		Gun gun = new Gun();
		gun.setBulletNumber(-5);
		gun.shoot();
	}
class Gun{
	//属于修饰词，被他修饰的成员变量只能在当前类中可见
	private  int bulletNumber;
	private int age;
	private int hight;
	private int mode1;
	private String name;
	//添加子弹的方法
//	public void addBullerNumber(int number) {
//	}
	public void setBulletNumber(int bulletNumber) {
		
		if(bulletNumber < 0) {
			this.bulletNumber = 0;
		}else {
			this.bulletNumber = bulletNumber;		}
	}
	public int getBulletNumber() {
		return bulletNumber;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getHight() {
		return hight;
	}
	public void setHight(int hight) {
		this.hight = hight;
	}
	public int getMode1() {
		return mode1;
	}
	public void setMode1(int mode1) {
		this.mode1 = mode1;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	//开枪射击
	public void shoot() {
		if(bulletNumber == 0) {
			--bulletNumber;
		}else{
		System.out.println("剩余的子弹数量"+--bulletNumber);
		}
	}
}

类的关系–继承

• extends：表示前面的继承后面的，如果一个类没有父类，默认继承Object

//创建他们的父亲
//如果一个类里没有父类，默认值Object
class Phone {
	String color;
	int model;
	public void callPhone() {
		System.out.println("打电话");
		
	}
}
//创建Hua类
class Huawei extends Phone{
//	String color;
//	int model;
	String niu;
	public void callPhone() {
		System.out.println("打电话");
		
	}
}

重写

• 当子类有与父类同名（方法的所有位置都相同）的方法时，我们称为重写，
• 注意点：子类的同名方法相当于把父类的覆盖了，父类的方法不会再被调用
• 作用：在不改变父类方法名的前提下，实现父类现有功能的基础上，实现功能的扩充；
• this：是一种引用数据类型，代表当前的对象，保存的是当前对象的地址
• super：不是引用数据类型，可以代表父亲，通过super可以调用父类的方法
• 注意点总结：
  • 1.私有方法不能被重写
  • 2.同名方法子类的权限大于等于父类的
  • 3.静态的方法只能覆盖静态的

//创建他们的父亲
//如果一个类里没有父类，默认值Object
class Phone {
	String color;
	int model;
	public void callPhone() {
		System.out.println("打电话");
		
	}
}
//创建Iphonei类
//  子类 extends 父类
class Iphone extends Phone{
//	String color;
//	int model;
	String gui;

	public void fangShui() {
		System.out.println("防水");
	}
	//重写父类的方法
	public void callPhone() {
		//System.out.println("打电话");
		//this.callPhone();//这里会有优先找子类的同名方法，造成死循环
		super.callPhone();//直接调到的是父类的方法
		
		//写自己的功能
		System.out.println("写自己的功能");
	}
}

继承使用构造方法

• 1.当一个类只有一个带参数的构造方法，只能使用带参数的，不能使用无参的，如果想使用，必须手动建立无参构造方法
• 2.创建构造方法的时候，如果我们不手动调用super（），系统会在自动调用父类无参构造方法
  • 原因：父类中也有成员变量需要进行初始化，而对象的成员变量只能由自己初始化所以必须调用super（），每个
  • 构造方法都会有默认的super（）
• 3.当父类中只有带参数的构造方法，子类的构造方法中就必须在第一行手动调用父类中带参数的构造方法super（参数）
  • 原因：因为在子类中有可能用到父类的成员变量，而成员变量在使用之前必须先进行初始化，否则不能使用
• 总结：在继承体系之中，最好就是将父类的无参，有参构造方法都生成

	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.play();
	}
class Animal{
	private String name;
	public Animal(String name) {
		super();
		this.name = name;
	}
	public Animal() {
		super();
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
}



class Dog extends Animal{
	public Dog() {
		super();//默认的代码，代表在调用父类空参的构造方法
	}
	public Dog(String name) {
		//super代表的方法必须放在第一行
		super(name);//代表调用父类有参构造方法
		this.setName(name);
	}
	public void play() {
		System.out.println("play");
	}
}

单例设计模式

• 设计模式：将前人总结好的经验我们直接拿来使用，
• 一共有23种，常用的有单例设计模式，模板设计模式，工厂设计模式，装饰设计模式，适配器设计模式，代理设计模式，
• 单例设计模式：一个类只有一个对象，建立一个全局访问点，将它提供出去大家使用
  • 1.用户只允许有一个对象
  • 2.单例类
  • 3.全局的访问点：得到的唯一的对象就是全局的访问点，怎么做到全局？-----static
  • 4.提供出去？
  • 5.供大家使用-----单例的功能，通过给单例类添加成员实现
• 单例类的作用：
  • 1.可以实现两个对象之间的传值
  • 2.可以在全局范围内调用很多的功能。
  • 好处：可以让两个对象在完全没有关系的前提下，实现值得传递，降低了耦合性，提高了内聚性
• 耦合性，内聚性在微观上说：描述的是类与类之间的关系
  • 好处：我们应该尽量提高内聚性，减少耦合性，可以提高程序的健壮性，增加代码的可移植性，方便实现模块儿化编程
• 如何做到低耦合高内聚？
  • 在处理类鱼类的关系的时候，让类之间的关系越紧密耦合性越高，内聚性越低，反之，关系越松散耦合性越低，内聚性越高，

饿汉式

• 饿汉式：在定义变量的同时，完成赋值

class SingleInstance{
	//第二步：在单例类的内部创建当前类的对象，私有化,并变成静态的
	private static SingleInstance singleInstance = new SingleInstance();
	public int num; 
	public static SingleInstance1 getInstance;
	//第一步：将构造方法私有化
	private SingleInstance() {
		
	}
	//第三步：建立一个静态的公共的方法，将单例类对象提供出去
	public  static SingleInstance getInstance() {
		return singleInstance;
	}
	//功能区-----一般创建的是非静态的成员实现功能
	//创建成员变量
	//创建成员方法
}

懒汉式

• 懒汉式:开始只是定义变量，什么时候使用，什么时候负责制造

class SingleInstance1{
	//第三步：在单例类的内部创建当前类的对象，私有化,并变成静态的
	private static SingleInstance1 singleInstance = null;
	//第一步：将构造方法私有化
	private SingleInstance1() {
		
	}
	//第三步：建立一个静态的公共的方法，将单例类对象提供出去
	public  static SingleInstance1 getInstance() {
		if(singleInstance == null) {//为了保证对象的唯一性
			singleInstance = new SingleInstance1();
			}
		return singleInstance;
	}

修饰词final

• final:最终的，不可改变的
• 可以修饰的内容有
  • 类:final修饰的类不能有子类
  • 成员方法：final修饰的方法不能重写
  • 成员变量：被final修饰的变量必须先给一个值这个值不能被改变
  • 局部变量：被final修饰的变量是一个定值，不能被改变

class Pig{
	final String name = "bingbing";//被final修饰的变量必须先给一个值这个值不能被改变
	public void play(int a) {
		
	}
}
class XiaoPig extends Pig {
	public void play(int a) {
		
	}
}