Java基础 -Day05 -------------------持续更新

面向对象和封装

怎么抽象出类

1. 找出具有相同特征的对象的名词--类名

2. 找出类的属性-特征 和 方法-行为

构造方法

使用new关键字创建对象是调用的,用于构造对象以及完成对象的初始化操作

public 类名(参数列表){

//初始化操作;

}

程序会为类创建默认的无参构造方法,一旦写了有参构造, 默认的无参构造方法就不存在了

方法重载

1. 同一个类中,方法名相同

2. 参数列表不同 -- 参数的类型或数量不同

3. 和返回值类型,访问修饰符无关

封装的使用

概念: 将类的某些信息隐藏在类的内部,不允许外部直接访问或操作这些数据,通过提供的方法实现对这些信息的访问和操作.

封装的实现步骤:

1. 将属性私有化 private

2. 给属性添加getter和setter访问器

3. 在访问器中添加控制语句

static修饰的属性,方法,代码块

static修饰的属性和方法是静态方法,在类加载的时候就确定了,所以是类成员,调用的时候可以使用类名调用

static代码块 用作类的初始化,或者读取配置信息,加载静态资源

继承

为什么使用继承:

1. 增加代码的复用性

2. 增加代码的可维护性

3. 让程序的结构更清晰

4. ...

public class Dog extends Pet{

}

单根性: 一个类只能继承一个父类

传递性: 父类的父类也是他的父类

子类中,使用super调用父类成员

super() //构造方法

super.属性 //调用父类的属性

super.方法名() //调用父类的方法

不能被继承的情况

1. private修饰的成员

2. 不在同一个包中,由默认访问修饰符修饰的成员

3. 构造方法

方法重写

在子类中,重写父类的方法,方法名相同,参数列表相同,返回值相同或是其子类, 访问修饰符不能严于父类

访问修饰符:

访问修饰符	本类	同包	子类	其他
private	√
默认(friendly)	√	√
protected	√	√	√
public	√	√	√	√

继承中,父类和子类的赋值顺序

父类属性> 父类构造方法> 子类属性 > 子类构造方法

Object类

所有类的父类

方法	说明
toString()	返回当前对象本身的有关信息，按字符串对象返回
equals()	比较两个对象是否是同一个对象，是则返回true
hashCode()	返回该对象的哈希代码值
getClass()	获取当前对象所属的类信息，返回Class对象

重写toString方法 重写equals方法

public boolean equals(Object obj){

if(this == obj){

return true;

}

if(obj instanceof Dog){ //该对象是一只狗

Dog d = (Dog)obj;

//属性是否相同

if(this.getName()==(d.getName())&&

this.getLove()==d.getLove()&&

this.getHealth()==d.getHealth()&&

this.strain==(d.strain)){

return true;

}

}

return false;

}

抽象类

关键字:abstract

抽象类不能实例化对象

抽象方法: abstract修饰的方法

1. 抽象方法没有方法体

2. 抽象方法必须在抽象类中或者接口中

3. 抽象方法必须被子类实现(重写), 除非子类也是抽象类

final

修饰属性: 属性不能重新赋值(常量)

final修饰引用类型的变量是, 对象的值不能改变,但是对象的属性值可以改变

修饰方法: 方法不能被重写

修饰类: 类不能被继承

static

修饰类: 类不能被继承

静态(static):可以修饰类,方法,方法属性(可以用对象名调用,也可以用类名直接调用,调用的是同一个属性,共同属性可以用static修饰,节约内存)[不能修饰局部变量]

被static修饰的方法,可以通过创建对象调用(不需要对象)[[独立于方法],也可以直接调用.

没有被static修饰的方法,必须通过创建对象来进行调用[方法与对象绑定]

一个类中:普通方法可以用所有属性,静态方法不能使用没有被static修饰的属性

设计模式:

单例模式:

应用:java和数据库连接通道

设计模式:

单例模式:

• 饿汉式:

  private Singleton(){

  //预防反射破坏单例的手段

  if(INSTANCE!=null){

  throw new RuntimeException("单例对象不能重复创建");

  }

  System.out.println("private Singleton()");

  }

  private static final Singleton INSTANCE=new Singleton();

  public static Singleton getInstance(){

  return INSTANCE;

  }

  public static void otherMethod(){

  System.out.println("otherMethod()");

  }

  public Object readResolve(){

  //预防反序列化破坏单例

  return INSTANCE;

  }

• 枚举饿汉式

  publicenum Singleton2{

  INSTANCE;

  }

• 懒汉式 DCL解决多线程问题

  private Singleton()

  private static volatile Singleton INSTANCE=null;//解决变量可见性,有序性

  public static Singleton getInstance(){

  if(INSTANCE==null){

  synchronized(Singleton.class){

  if(INSTANCE==null){

  INSTANCE=new Singleton();

  }

  }

  }

  return INSTANCE;

  }

  public static void otherMethod(){

  System.out.println("otherMethod()")

  }

• 单例模式在jdk中体现

  • System的exit方法使用runtime的exitt

  • System的gc方法使用runtime的gc

  • Runtime方法

  • System的console对象使用双检锁方法

代码执行顺序(简单代码,不涉及继承):静态资源>静态方法>普通资源>普通块>构造器

属性的诞生和属性的赋值不是同步的

接口:

接口:interface 用implements实现,使用多个接口用","间隔

接口的特性:

        1.接口不可以被实例化

        2.实现类必须实现接口的所有方法

        3.实现类可以实现多个接口

        4.接口中的变量都是静态常量

面向接口编程:

1. 关心实现类有何能力，而不关心实现细节

2. 面向接口的约定而不考虑接口的具体实现

接口有比抽象类更好的特性：

        1.可以被多继承

        2.设计和实现完全分离

        3.更自然的使用多态

        

        4.更容易搭建程序框架

        

        5.更容易更换实现

接口和抽象类:

        相同点

                1.代表系统的抽象层

                2.都不能被实例化

                3.都能包含抽象方法

                4.用于描述系统提供的服务，不必提供具体实现

        

        不同点

                1.在抽象类中可以为部分方法提供默认实现，而接口中只能包含抽象方法

                2.抽象类便于复用，接口便于代码维护

                3.一个类只能继承一个直接的父类，但可以实现多个接口