Java面向对象的基本概念-static和继承

static变量

• 成员变量

静态变量，可以直接通过类名访问

• 成员方法

静态方法，可以直接通过类名访问

• 代码块

静态代码块，当Java虚拟机加载类时，就会执行该代码块

类变量（静态变量）

被static修饰的变量

在内存中只有一个拷贝//static变量修饰的类被所有的对象共享

类内部，可在任何方法内直接访问静态变量

其他类中，可以直接通过类名访问

实例变量

没有被static修饰的变量

每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响

方法:

静态方法不能访问非静态方法,只能访问静态方法

非静态方法可以访问非静态方法,也可以访问非静态方法

可直接访问所属类的静态变量、静态方法、实例变量和实例方法

 

继承

1. 如何继承:

编写父类

[访问修饰符] class Pet{

                //公共的属性和方法

}

编写子类 继承父类

[访问修饰符] class Pet  extends Pet{

                //子类特有的属性和方法

}

	public class Animal {
		//定义属性
		private String name;
		
		//无参构造
		public Animal() {
		}
	
		public Animal(String name) {//有参构造
			this.name = name;
		}
	
		public String getName() {
			return name;
		}
	
		public void setName(String name) {
			this.name = name;
		}
		
	}
	public class Dog extends Animal {
		private String color;
		
		public Dog(){
			super();
		}
		
		public Dog(String color){
			this.color=color;
		}
	
		public String getColor() {
			return color;
		}
	
		public void setColor(String color) {
			this.color = color;
		}
		
	}
	public class Test {
	
		public static void main(String[] args) {
			Dog dog=new Dog();
			dog.setName("小花");
			System.out.println("名字是"+dog.getName());//子类没有setname方法,继承了父类的方法
		}
	
	}

1. 子类访问父类成员

使用super调用父类中重写的方法,访问父类隐藏的字段

• 使用 super关键字  ,super代表父类对象
• 在子类构造方法中super必须在第一行
• 不可以访问父类中private修饰的属性和方法

	public class Animal {
		//定义属性
		public String name="animal";
		public void say(){//父类中的say方法
			System.out.println("我是父类Animal中的say");
		}
		
	}
	public class Dog extends Animal {
		public String name="旺财";
		public void say(){//重写父类中的say方法
			super.say(); 		//使用super调用父类中的方法
			System.out.println("我是子类Dog中的say");
			System.out.println("父类的名字是"+super.name);//使用super调用父类的name属性
		}
		
	}
	public class Test {
	
		public static void main(String[] args) {
			Dog dog=new Dog();
			dog.say();   //调用子类重写的方法
			System.out.println("子类的名字是"+dog.name);//调用子类name
		}
	
	}

super调用父类无参/有参构造方法

子类不继承其父类的构造方法。

• 当使用无参数的super()时，父类的无参数构造方法就会被调用；
• 当使用带有参数的super()方法时，父类的有参数构造方法就会被调用。

	public class Animal {
		//定义属性
		private String name;
		private int  health;
		private int love;
		
		Animal(){//无参构造
			System.out.println("我是父类Animal无参构造");
		}
		
		Animal(String name,int health,int love){//有参构造
			super();//调用object类
			this.name=name;
			this.health=health;
			this.love=love;
			System.out.println("我是父类Animal有参构造");
		}
	
		public void say(){
			System.out.print("我的名字是"+this.name+"健康值是"+this.health+"亲密度是"+this.love);
		}
	}
	public class Dog extends Animal {
		private String sex;
		
		Dog(){//无参构造
			System.out.println("我是子类Dog无参构造");
		}
		
		Dog(String sex,String name,int health,int love){
			super(name,health,love);//父类中带参数的构造器
			this.sex=sex ;
			System.out.println("我是子类Dog有参构造");
		}
	
		public void say(){
			super.say();//调用父类的方法
			System.out.println("我的性别是"+this.sex);
		}
	}
	public class Test {
	
		public static void main(String[] args) {
			Dog dog1=new Dog();//调用子类和父类的无参构造方法
			Dog dog2=new Dog("公","旺财",100,30);//调用子类和父类的有参构造方法
			dog2.say();//调用子类和父类的方法
		}
	
	}

输出结果:

我是父类Animal无参构造
我是子类Dog无参构造
我是父类Animal有参构造
我是子类Dog有参构造
我的名字是旺财健康值是100亲密度是30我的性别是公