昨天知识总结
- 1.static
- 成员变量和局部变量的区别
- static修饰成员后的作用
- static作用总结
- 2.构造方法
- 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 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
class Phone {
String color;
int model;
public void callPhone() {
System.out.println("打电话");
}
}
class Huawei extends Phone{
String niu;
public void callPhone() {
System.out.println("打电话");
}
}
重写
- 当子类有与父类同名(方法的所有位置都相同)的方法时,我们称为重写,
- 注意点:子类的同名方法相当于把父类的覆盖了,父类的方法不会再被调用
- 作用:在不改变父类方法名的前提下,实现父类现有功能的基础上,实现功能的扩充;
- this:是一种引用数据类型,代表当前的对象,保存的是当前对象的地址
- super:不是引用数据类型,可以代表父亲,通过super可以调用父类的方法
- 注意点总结:
- 1.私有方法不能被重写
- 2.同名方法子类的权限大于等于父类的
- 3.静态的方法只能覆盖静态的
class Phone {
String color;
int model;
public void callPhone() {
System.out.println("打电话");
}
}
class Iphone extends Phone{
String gui;
public void fangShui() {
System.out.println("防水");
}
public void 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(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";
public void play(int a) {
}
}
class XiaoPig extends Pig {
public void play(int a) {
}
}