Java-第二章类与继承重载重写接口等

java基于的是对象和类，这么基础的东西第二步才是为了方便测试。类对于熟悉c#的我来说比较容易理解了，用我自己的理解来讲，当我们编程时可能会需要一个基本的功能，比如说需要一个管理所有信息和显示的基本功能，我们可以创建一个基本的集合类，当我们管理学生信息时需要弄一个学生管理，需要饭店信息的时候又弄一个饭店管理，但是他们基本的东西都是一样的，就是数据的处理略微不同，那么我们为什么不弄一个模板，对于不同的情况稍微更改一下就可以通用了。

一个类，它可以被继承，重写部分内容，而关于多态，抽象，虚拟，接口，重载这种更加抽象的内容我们简单的使用例子来理解一下：

继承与重写

//我们有三个动物 猫狗猪 如果想让他们见我们需要分别的实例化每个单个的无联系的类 然而他们的共同点太多， 吃 睡 跳 对我们来说每个都单独的写一个类是侠侣很低的
class mainclass {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.shout();
    }
}

class Dog{
    void shout()
    {
        System.out.println("wang~wang~");
    }
}

class Cat{
    void shout()
    {
        System.out.println("miao~miao~");
    }
}

class Pig{
    void shout()
    {
        System.out.println("heng~heng~");
    }
}

对此我们可以创建一个动物的模板，每个都在其上进行修改，这就是所谓的继承的意思，而重载则是对于与模板不同的地方需要进行少部分的更改。

重写(Override)是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！，同一功能实现不同

class mainclass {
    public static void main(String[] args) {
        Animal ani = new Animal();
        ani.shout();    
        Animal dog = new Dog();
        dog.shout();
    }
}

class Animal{
    void shout()
    {
        System.out.println("voice~voice~");
    }
}

class Dog extends Animal
{
    void shout()
    {
        System.out.println("wang~wang~");
    }
}

voice~voice~
wang~wang~
//继承使用关键词extends 而后如果有相同的函数 那么视作重写了原函数功能
//如果想要继续在子类中调用原函数的功能 使用super关键字
void shout()
{
    super.shout();
    System.out.println("wang~wang~");
}

方法的重写规则

参数列表必须完全与被重写方法的相同；
返回类型必须完全与被重写方法的返回类型相同；
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
父类的成员方法只能被它的子类重写。
声明为final的方法不能被重写。
声明为static的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写。
如果不能继承一个方法，则不能重写这个方法。

重载

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。对于同一功能输入不同的情况

class mainclass {
    public static void main(String[] args) {
        Add add = new Add();
        add.add(1,2);
        add.add(1,2,3);
    }
}

class Add{
    
    void add(int a,int b)
    {
        System.out.println(a+b);
    }
    
    void add(int a,int b,int c)
    {
        System.out.println(a+b+c);
    }
}
3,6
//可以看到对于add有两个相同的函数 只有参数不一样 但是是可以用的 根据输入程序自动选择对应的函数

重载规则:

被重载的方法必须改变参数列表(参数个数或类型不一样)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。

类的构造器

用于初始化类的新实例的时候，传递参数，并且一个类可以有多个不同类型的构造器，也就是类似于重载

class Dog
{
    int age;
    String name;
    Dog(String name)
    {
       this.name = name;
    }
    
    Dog(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
}

//实例化时候可以
Dog dg = new Dog("huahua");
Dog dg = new Dog("huahua",12);

接口

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

一个接口不能有可变的实例和类变量。与类不同，接口不能被实例化。接口的所有成员都是隐式公开的，接口中的所

有字段都是隐式的public，static和final(当不希望父类的某个方法被子类覆盖（override）时，可以用final关键字修饰)

final注意事项

（1）final修饰的变量又叫常量，一般用xx_xx_xx来命名

（2）final修饰的变量在定义时，必须赋初值，并且以后不能再赋值

final—什么时候用

（1）因为安全的考虑，类的某个方法不能修改

（2）类不能被其他的类继承

（3）某些变量值是固定不变的，比如圆周率等

其中可以包含的包括：

l常量字段

l抽象，静态和默认方法

l静态类型作为嵌套接口和类

看一下小例子

public class Test
{
	public static void main(String[] args)
	{
        Dog dg = new Dog();
		dg.shout();
		dg.cal();
	}
}

interface IShout  //叫的接口 默认声音数量三声
{
    int shoutnum = 3;
	public void shout();
}

interface ISize  //吃的接口 默认吃的是饲料
{
    double pi = 3.1415;
	public void cal();
}


class Dog implements IShout,ISize  //狗继承叫的接口 计算大小的接口
{
    int r = 5;
	public void Dog(int shoutnum)
	{
		
	}
	
    //叫 具体的实现
	public void shout()
	{
		for(int i = 0; i < shoutnum; i++)
		{
			System.out.println("wang~");
		}
	}
    
    //计算 具体的实现 
    public void cal()
    {
        System.out.println("Dog size = " + 2*pi*r);
    }
}

抽象类

抽象类是用来捕捉子类的通用特性的。它不能被实例化，只能被用子类来继承并且实现其具体的方法等。抽象类是被用来继承的模板，一听感觉跟接口很像，但是却别也很明显，

抽象使用abstract 关键字标识，如果是继承接口，那么就必须确保使用这些方法。接口只是一种形式，接口自身不能做任何事情。具体的对比如下：

抽象是实现默认方法的，接口只是列出必有的方法，这是最关键的部分吧。其他的构造器 main 多继承等自己想一想就可以明白了，下面有一个小例子

public class Test
{
	public static void main(String[] args)
	{
        //无参数的狗
        Dog dg = new Dog();
		dg.shout();
		dg.eat();
		
        //有参数的狗
		Dog dg2 = new Dog("骨头");
		dg2.eat();
	}
}

interface IShout  //叫的接口 默认声音数量三声
{
    int shoutnum = 3;
	public void shout();
}

//抽象类 里面的字段是可以更改的
abstract class AEat
{
    public String eatwhat = "饲料";
    //方法包含默认实现 子类继承时可以重写
	public void eat()
	{
		System.out.println("Dog eat = " + eatwhat);
	}
}


class Dog extends AEat 
	implements IShout   //狗继承叫的接口
{
    
	Dog(String what)
	{
		eatwhat = what;
	}
		
	Dog()
	{
	
	}
	
	public void shout()
	{
		for(int i = 0; i < shoutnum; i++)
		{
			System.out.println("wang~");
		}
	}
    
    //如果没有这个重写的函数 那么使用的就是原本的抽象类中的实现
    public void eat()
    {
        System.out.println("new Dog eat = " + eatwhat);
    }
}

总而言是关键的几点就是：

抽象类的字段可以在继承中重写，接口的不能
继承时需要实现接口中的函数，而抽象类中的函数时已经写好的，可以重写。
一个抽象类可以继承一个抽象类和多个接口接口只能继承接口。