java继承相关知识

Java的三大特征：封装  继承  多态

Java继承：继承只能是单继承，只能有一个父类，但是可以多重继承。

class  A{

}

class B extends A{

}

class C extends B{

}这是多重继承

在中国而言继承的关系就是：儿子去继承父类的所有东西。

在代码中继承的语法格式：class  B   extends  A{

                                             可以继承父类所相关的属性和方法。

                                            }

使用关键字：extends关键字

class B extends A{


}
B继承了A     B是A的儿子     A是B的父亲   B可以继承父类A所有的东西
class Person{
     String name;
     int age;
     double weight;
     //父类下面的方法
     public void eat(){
       System.out.println("在吃窝窝饭");
      }
}
class Man extends Person{

}
public class Demo1{
   public static void main(String[] args){
     Man man = new Man();
     man.name="鲜明";
     man.age=29;
     man.weight=12.2;
     System.out.println(man.name);
     System.out.println(man.age);
     System.out.peintln(man.weight);
     //使用对象.调用方法
     man.eat();
     }

}

继承注意事项：

成员变量：公开的和默认的成员变量，则子类可以继承父类的。 

                  私有化的成员变量则子类不可以继承。

成员方法：公开的和默认的成员方法，则子类可以继承父类。

                  私有化的成员方法，则子类不可以继承。

构造方法：如果父类中有有参构造，没有无参构造那么子类会报错。

                   如果父类中没有无参构造，那么子类也是不能有无参构造的。

                  先执行父类的构造方法，在执行子类的构造方法。

                  父类的构造方法必须和子类的构造方法保持一致。

在开发中遇到了私有化的变量和属性如何解决？

使用Set和Get进行赋值和取值。

class Animal{
   private int age;//私有化的变量
   private String name;
   private double weight;
   public void setName(String name){
     this.name=name;
}
   public String getName(){
     return name;
}
   public void setAge(int age){
    this.age=age;
}
   public int getAge(){
    return age;
}
   public void setWeight(double weight){
    this.weight=weight;
}
   public double getWeight(){
    return weight;
}
   public void sleep(){
    System.out.println("动物在睡觉");
}
   public void eat(){
    System.out.println("动物在吃饭");
}
}
class Dog extends Animal{//Dog继承了变量Animal
 
}
public class Demo2{
public static void main(String[] args){
   Dog dog = new Dog();
   dog.setAge(22);
   dog.setName("小明");
   dog.setWeight(100.0);
   System.out.println(dog.getName());
   System.out.println(dog.getAge());
   System.out.println(dog.getWeight());
}
}

构造方法

分为无参构造和有参构造

类中有无参构造和有参构造，当new对象的时候会自动匹配构造方法

class Dog {
    public String name;//公开的成员变量
    int age;//默认的成员变量
    public void eat(){
     System.out.println("在吃饭");//公开的成员方法
}
    void sleep(){
     System.out.println("默认的成员方法");
}
    public Dog(){//构造方法是用来初始化类对象的，可以对属性进行的赋值，对象的创建就是依据构造方法来创建的。
     
}
    public Dog(String name,int age){
     this.name=name;
     this.age=age;
}
}
class Ca extends Dog{
    //小爱对着String name 22对照着的int age
    public Ca(String name,int age){//子类中的有参构造
       this.name=name;
       this.age=age;
    }
}
public class Demo3{
  public static void main(){
    Ca ca = new Ca("小爱",22);//当new ca的时候会对照着子类中的有参构造 
    ca.name="小猫";
    ca.age=22;
    //结果为小猫  22 因为上面的赋值的早所以会被覆盖掉
    System.out.println(ca.name);
    System.out.println(ca.age);

}
  
}

继承的案例

Animal 类:

​			属性 : name, age ,sex  私有化的

​			方法: 吃 运动

​	子类：Panda

​			使用Panda继承Animal  并可以使用Animal下面的所有属性和方法，对属性进行赋值

​			方法调用
class Animal{
    String name;
    int age;
    char sex;
    public void eat(){
     System.out.println("再吃");
}
    public void  sleep(){
     System.out.println("在运动");
 }
}
class Panda extends Animal{
    

}
public class Demo2{
   public static void eat(){
      panda.name="小动物";
      panda.age=20;
      panda.sex='男';
      System.out.println(panda.name);
      System.out.println(panda.age);
      System.out.println(panda.sex);
      //调用方法 对象.方法的名字
      panda.eat();
      panda.sleep();

}
}

override重写

重写的目的：子类可以继承父类的属性和方法，但是父类方法的需求已经满足不了子类了，则需要在子类中重写方法。

override重写的用法
class Person{
    String name;
    int age;
    double weight;
    public void eat(){
     System.out.println("在吃窝窝头");
}
    public void sleep(){
     System.out.println("在睡觉");
}
}
class Man extends Person{
    //父类的需求已经满足不了子类了，则需要重写
    public void eat(){
     System.out.println("再吃烤肠");
}
    public void sleep(){
     System.out.println("在沙发上舒服的休息着");
}
}
public class Demo3{
   public static void main(String [] args){
     Man man = new Man();
     //重写了父类的方法
     man.eat();
     man.sleep();
     man.name="洗脑";
     man.age=22;
     man.weight=100.0;
     System.out.println(man.age);
     System.out.println(man.name);
     System.out.println(man.weight);
}
}

overload重载

重载的目的：在同一个类中，方法的名字可以一样但是参数一定不一样，返回值可以一样也可以不一样。

class Animal{
	public void eat() {
		System.out.println("再吃饭");
	}
	public void eat(String name) {
		System.out.println(name);
	}
	public void eat(int i) {
		System.out.println(i);
	}
	public void eat(double d1) {
		System.out.println(d1);
	}
}
public class Test6{
	public static void main(String[] args) {
		Animal animal = new Animal();
		animal.eat();
		animal.eat("小明");
		animal.eat(22);
		animal.eat(100.0);
		
		
	}
}