继承知识点总结，懒汉饿汉单例模式，抽象类

7-22总结

---

• Eclipse 快捷键使用

  • ctrl+a 全选
  • ctrl+i 自动对齐
  • ctrl+s 保存
  • ctrl+z 撤销
  • ctrl+y 前进
  • ctrl+/ 单行注释/取消单行注释
  • ctrl+shift+/ 多行注释
  • ctrl+shift+\ 取消多行注释
  • ctrl+d 删除整行
  • alt+上/下 快速移动代码
  • alt+/ 快捷提示

• 单例模式： 指得是在一个类中，有且只有一个实例对象，比如宇宙类中只有一个地球对象

  • 饿汉式单例模式： 通过私有化构造方法，使得外部类无法通过new来创建对象，在类中提供了一个public的static方法 外部调用者通过该方法获得对象，每次获得的对象都是指向同一个对象，从而达到单例的目的，无论如何都会创建一个对象。

      public class GianDragon {
  	
  	String name;
  	//私有化构造方法使得该类无法在外部通过new进行实例化
  	private GianDragon(){
  		
  	}
  	private GianDragon(String name){
  		this.name = name;
  	}
  	
  	//定义一个类属性，指向一个实例化对象，类属性只有一个，且无法修改
  	private static GianDragon instance = new GianDragon("男爵");
  	//定义一个类方法 提供给调用者16行所定义的对象
  	public static  GianDragon getGianDragon(){
  		return instance;
  	}
  
  }
  

  • 懒汉单例模式：

  public class GianDragon2 {
  
  private GianDragon2(){
  	//私有化构造函数，使其不能从类外实例化对象
  }
  
  //设定一个类属性 用来指向一个实例化对象，暂时指向null
  private static GianDragon2 instance; //只有需要这个实例对象的时候 调用ge
  //getInstance方法才会生成实例，懒汉就是你要对象才给你对象，饿汉是类一加载就生成一个实例对象
  						
  public static GianDragon2 getInstance(){
  	//返回  instance引用   它的类型为GianDragon2实例对象
  	if(instance ==null){
  		instance = new GianDragon2();
  	}
  	return instance;
  }
  

}
```

• 继承

  • 概念： 子类中存在相同的属性和行为时，将这些内容抽取到单独的一个父类中，那么多个类就无需再定义这些相同的属性和行为，只要继承父类即可，例如燕子，麻雀，老鹰，都是属于鸟类，都有飞的行为，都有翅膀，都是两条腿，让其继承鸟类即可
  • 定义： 继承就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性和行为，子类可以直接访问父类中飞私有的属性。
  • 成员变量同名： 父类和子类有成员变量重名且值不同的时候，子类访问该属性，显示的是子类的属性

  class Fu{
      int num = 5;
  }
  class Son extends Fu{
      int num = 6;
      
      public void show(){
          System.out.println(num);
      }
  }
  class Test
      public static void main(String[] args){
          Son s = new Son();//创建一个子类对象
          s.show();//输出的是子类的num ,6
      }
  

  • **子类访问父类非私有重名成员变量：**子类和父类出现同名成员变量时，子类要访问父类中非私有的成员变量时，需要用到super关键字，修饰父类成员变量

  • 子类重写父类方法： 子类可以直接访问父类中非私有的成员方法，如果父类中的成员方法不满足子类需求时，子类可以重写父类的成员方法(返回值类型，方法名，参数列表一致)，方法实现功能不同。

  • 构造方法: ：子类无法继承父类的构造方法，因为构造方法与类名一致。构造方法的作用是初始化对象的属性(也就是类的成员变量)，所以子类初始化过程中，必须先执行父类的初始化动作，子类构造方法默认有一个super()默认调用父类的构造方法。

  public class Father {
  
  String name;
  int age;
  //构造方法
  public Father(){
  }
  
  //带参数的构造方法
  public Father(String name, int age){
  	this.name = name;
  	this.age = age;
  	
  }
  }
  public class Son extends Father{
  	
  	double height;
  	double weight;
  	
  	public Son(){
  		//无参构造方法
  	}
  	
  	//带参数构造方法
  	public Son(String name, int age, double height, double weight){
  		super(name,age);
  		this.height = height;
  		this.weight = weight;
  	}
  
      }
  public class Test {
  	public static void main(String[] args) {
  		Son pc = new Son("小小",100, 170,120);
  		System.out.println(pc.name);
  		System.out.println(pc.age);
  		System.out.println(pc.height);
  		System.out.println(pc.weight);
  	}
  }
  

  • 继承的特点
    • 单根性： Java只支持单根性，一个子类只能有一个父类
    • **复用性：**增加了代码的复用性，减小了工作量

• 抽象类

  • 抽象类定义： 包含抽象方法的类就是抽象类，用abstract修饰，且抽象类不能实例化对象(没有意义)
  • 抽象方法的定义： 只有方法声明，没有方法体的方法，用abstract修饰

  //定义抽象方法
  修饰符 abstract 返回值类型 方法名(参数列表);
  
  public abstract void run();//没有方法体 只有方法声明
  
  
  //定义抽象类
  abstract class 类名{
      public abstract void run();//抽象方法
  }
  

  • 继承抽象类的子类必须实现（重写）抽象类的所有抽象方法 否则该类也必须声明为抽象类

      public abstract class Animal {
  	
  	public abstract void run();//抽象方法
  }
  
      public class Cat extends Animal{
  	
  	@Override
  	public void run(){
  		System.out.println("小猫在跑");
  	}
  
  }