java笔记

JAVA继承

继承的的概念：

• 继承是一种类与类之间的关系
• 使用已存在的类的定义作为基础建立新类
• 作为基础的类一般称为父类(基类)，创建的新类称为子类(派生类)
• 新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性的继承父类

类的继承格式：

public class 父类(){

}
public class 子类(){

}

继承的优点:

1、提高了代码的复用性

2、提高了代码的维护性

3、建立了类与类之间的关系，继承是多态的前提。

继承缺点:

1、在一定程度上，造成类与类之间的强关联，即所谓的高耦合。

2、父类功能的改变对子类也会造成影响。

super 与this 关键字：

• super关键字：
  我们可以通过super关键字来是新啊对父类成员的访问，用来引用当前的对象的父类。

• this关键字：
  指向自己的引用。

   public class Animal
    {
    	void eat()
    	{
    		System.out.println("animal: eat");
    	}	
    }
    
   public class Dog extends Animal
    {
    	void eat()
    	{
    		System.out.println("dog :eat")
    	}
    	void eatTest()
    	{
    		super.eat();   /// 调用父类的方法
    		this.eat();    //调用自己的方法
    	}
    }

public class Test
{
	public static void main(String[] args)
	{
	Animal  a=new Animal();
	a.eat()
	Dog d = new Dog();
	d.eatTest();
	}
}

输出结果：

animal ：eat
dog : eat
animal : eat

方法重写：

方法重写出现在有继承关系的子类中，以下几个要素都要与父类继承的方法相同

• 返回值类型
• 方法名
• 参数类型、顺序、个数

方法重载：

同一个类中的多个方法可以有相同的方法名称，但是有不同的参数列表，这就称为方法重载（method overloading）。

参数列表又叫参数签名，包括参数的类型、参数的个数、参数的顺序，只要有一个不同就叫做参数列表不同。

访问修饰符的分类及使用：

访问修饰符	本类	同包	子类	其他
private	yes	no	no	no
默认	no	yes	no	no
protected	yes	yes	yes	yes
public	yes	yes	yes	yes

JAVA多态

多态时同一种行为具有多个不同的表现形式或形态的能力。

多态存在的三个必要条件：

• 继承
• 重写
• 父类引用指向子类对象

实例：

public class Animal {
    private String name;
    private int month;
    
    public Animal(){}
    public Animal(String name, int month){
        this.setName(name);
        this.setMonth(month);
    }
    //此处省略getter/setter···
    public void eat(){
        System.out.println("动物都有吃东西的能力")
    }
}

//Cat类
public class Cat extends Animal{
   private double weight;
   
   public Cat(){}
      public Cat(String name, int month, double weight){
          super(name,month);
          this.setWeight(weight);
      }
      //此处省略 getter/setter···
      public void run(){
          System.out.println("小猫快乐的奔跑")
      }
      @Override
      public void eat(){
          Sysout.out.println("小猫吃鱼")
      }
}

//Dog类
public class Dog extends Animal{
    private String sex;

    public Dog(){}
    public Dog(String name,int month,String sex){
        super.setName(name);
        super.setMonth(month);
        this.setSex(sex);
    }
    //此处省略getter/setter···
    public void sleep(){
        System.out.println("小狗有午睡的习惯")
    }
    @Override
    public void eat(){
        System.out.println("小狗吃骨头")
    }
}

向上转型：

向上转型即父类引用指向子类实例。

public class Test{
   public static void main(String[] args){
       Animal a1 = new Animal();
       //向上转型、隐式转型、自动转型
       Animal a2 = new Cat();
       Animal a3 = new Dog();
       a1.eat();//动物都有吃东西的能力
       a2.eat();//小猫吃鱼
       a3.eat();//小狗吃骨头
   }
}

向下转型：

Cat temp = (Cat) animal;

运算符：

instanceof 运算符

//用于判断 obj 是否是 Classname 的实例或者是派生类实例
boolean flag = obj instanceof Classname;

单例设计模式：

单例模式的定义：指一个类只有一个实例，且该类能自行创建这是实例的一种模式。

单例模式设计要点：

1、单例类只有一个实例对象
2、该单例对象必须由单例类自行创建
3、单例类对外提供一个访问该单例的全局访问点

单例模式代码实现：

1、只提供私有的构造方法
2、含有一个该类的静态私有对象
3、提供一个静态的公有的应用于创建、获取静态私有对象

饿汉模式：

//饿汉模式：创建对象实例的时候直接初始化

public class HungrySingletion{
     //1、创建类中私有构造方法
     public HungrySingletion(){}
     //2、创建该类型的私有静态实例
     private static final HungrySingletion instance = new HUngrySingletion()
     //3、创建公有静态方法返回静态实例对象
     public static HungrySingletion getInstance(){
        return instance;
     }
}

懒汉模式：

/**
*懒汉模式：类内实例对象创建时并不直接初始化，
*          知道第一次调用get方法，才完成初始化
*/
public class LazySingletion{
     //1、创建类中私有构造方法
     public LazySingletion(){}
     //2、创建该类型的私有静态实例
     private static LazySingletion instance = null;
     //3、创建公有静态方法返回静态实例对象
     public static LazySingletion getInstance(){
       if (instance == null){
           instance = new LazySingletion();
       }
       return instance;
     }
}

Java 接口

接口类相似于类，但接口成员没有执行体，它只是方法、属性、事件、和索引符的组合而已。接口不能被实例化，接口没有构造方法，没有字段，在应用的程序中，接口就是一种规范，它封装了可以被多个类继承的公共部分。

Java为什么需要接口

1、通过接口实现多继承
2、用于实现耦合
如下图所示，一个类扩展了另一个类，一个接口扩展了另一个接口，一个类实 现了一个接口。

接口的用法：

interface Printer{                                                                //打印机的接口
	void print();                                                        //打印机的打印方法
}

电脑来了

class  Computer implements Printer{                                           //computer连接了Printer的方法
	@override
	public void print(){
		System.out.println("我是电脑");                                        //把msg的方法打印出来
	}
}

手机来了

class SmartPhone implements Printer{                                   //手机连接了打印机
	@override
	public void print(){
		System.out.println（"我是智能手机"）；                           //手机的println()方法
	}
}

Java 8接口特性：

Java 8以前的接口只能有抽象方法，不能有方法体
Java 8开始可以有方法体，但是只能是默认的方法体和静态方法

Java 抽象类

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。
父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。
在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

抽象方法：

• 使用abstract修饰的方法我们称之为抽象方法。
• 抽象方法不含有方法体
• 含有抽象方法的类一定是抽象类，抽象类不一定有抽象方法
• abstract关键字只能用于普通方法，不能用于 static 方法或者构造方法中

public abstract class Animal{
    public abstract void eat();
}