第九天笔记

static关键字和继承

1.static关键字

1.1static修饰符

static修饰的属性。称之为静态属性，或者静态变量，也叫类变量，在内存中只有一份拷贝；可用于共享数据；同时也可以节省内存空间。

静态属性 变量

储存特点：在内存中只有一份拷贝 用于数据共享 不同实例变量 实例变量是每创建一个对象 就有一份拷贝

不同的位置访问静态变量

访问方式：

1.普通方式中 本类中直接访问 其他类通过类名+点 访问

2.静态方法中 本类中直接访问 其他类通过类名+点 访问

3.构造方法中 同上

4.静态代码块 直接访问 其他类通过类名+点 访问

5.普通代码块 直接访问 其他类通过类名+点 访问

定义位置：

1.普通方法： 不能再普通方法内中定义静态变量

2.静态方法： 静态方法中也不能定义静态变量

3.构造方法： 也不能定义

4.静态代码： 也不能定义

5.普通代码： 也不能定义

package com.qfedu.test2;
/**
 * 	静态属性 变量  
 * 	存储特点：在内存中只有一份拷贝 用于数据共享  不同于实例变量 实例变量是每创建一个对象 就有一份拷贝 
 * 	不同的位置访问静态变量 
 * 	访问方式 ： 
 * 	1.普通方法中 本类中直接访问 其他类通过类名+点 访问 
 * 	2.静态方法中 本类中直接访问 其他类通过类名+点访问
 * 	3.构造方法中 同上
 * 	4.静态代码块 直接访问	其他类通过类名+点 访问 
 * 	5.普通代码块 直接访问	其他类通过类名+点 访问 
 * 	定义位置：
 * 	1.普通方法 不能再普通方法中定义静态变量
 * 	2.静态方法 静态方法中也不能定义静态变量
 * 	3.构造方法 也不能定义
 * 	4.静态代码块 不能定义
 * 	5.普通代码块  不能定义
 * @author WHD
 *
 */
public class TestStaticField {
	static int num = 20;
	
	static {
//		static int a = 20; 不能在这里定义静态变量
		int a = 20;
		System.out.println(num);
	}
	
	{
//		static int a = 20; // 不能在这里定义静态变量
		System.out.println(num);
	}
	
	public void m1() {
		// static int a = 30; 不能再普通方法中定义静态变量
		System.out.println(num);
	}
	
	public TestStaticField() {
		// static int a = 30; 构造方法也不能定义静态变量
		System.out.println(num);
	}

	
	public static void main(String[] args) {
		// static int a = 30; 静态方法中也不能定义静态变量
		System.out.println(num);
	}
	
}

class Test1{
	public void m1() {
		System.out.println(TestStaticField.num);
	}
	
	public static void main(String[] args) {
		System.out.println(TestStaticField.num);
	}
	
	public Test1() {
		System.out.println(TestStaticField.num);
	}
	
	
}

package com.qfedu12;

public class Static {
	static int age;
	
	//普通方法
	public void print() {
		System.out.println("我是普通方法！" + age);
		//static int year;普通方法中不能定义静态属性
	}
	//构造方法
	public Static(){
		System.out.println("我是构造方法！" + age);
		//static int year;构造方法中也不能定义静态属性
	}
	
	//静态代码块
	static {
		System.out.println("我是静态代码块！" + age);
		//static int year;静态代码块中不能定义静态属性
	}
	
	//普通代码块
	{
		System.out.println("我是普通代码块！" + age);
		//static int year;普通代码块中也不能定义静态属性
	}
	
	//static方法
	public static void main(String[] args) {
		Static one = new Static();
		one.print();
		System.out.println("我是static方法，我应该是最后！" + age);
		//static int year;静态方法中也不能定义静态属性
	}
	
	
}

1.2static修饰方法

static修饰的方法称之为静态方法，属于整个类，不属于任何对象。

静态方法

访问方式：

1.普通方法： 本类中直接访问 其他类通过类名+点访问

2.静态方法： 本类中直接访问 其他类通过类名+点访问

3.构造方法： 本类中直接访问 其他类通过类名+点访问

4.静态代码块： 直接访问 其他类通过类名+点方式访问

5.普通代码块： 直接访问 其他类通过类名+点方式访问

package com.qfedu.test2;
/**
 * 	静态方法
 * 	访问方式
 * 	1.普通方法 	本类中直接访问 其他类通过类名+点方式访问
 * 	2.静态方法	本类中直接访问 其他类通过类名+点方式访问
 * 	3.构造方法	本类中直接访问 其他类通过类名+点方式访问
 * 	4.静态代码块	直接访问 其他类通过类名+点方式访问
 * 	5.普通代码块 直接访问 其他类通过类名+点方式访问
 * @author WHD
 *
 */
public class TestStaticMethod {
	public static void m1() {}
	
	static {
		m1();
	}
	
	{
		m1();
	}
	
	public void m2() {
		m1();
	}
	
	public static void m3() {
		m1();
	}
	public TestStaticMethod() {
		m1();
	}
	
	
}

class Test2{
	public void m1() {
		TestStaticMethod.m1();
	}
	
	public static void m2(){
		TestStaticMethod.m1();
	}
	
	public Test2() {
		TestStaticMethod.m1();
	}
}

1.3static修饰代码块&普通代码块

static修饰符的代码块称之为静态代码块，在类加载的时候就自动运行，多个静态代码块按照书写顺序执行，且只执行一次。

普通代码块，每创建一次对象就执行一次。

package com.qfedu.test2;
/**
 * 	静态代码块
 * 	语法格式 static { // 代码}
 * 	访问方式 不能调用 类加载的时候 就自动执行 
 * 	类什么时候被加载？当我们第一次访问这个类的时候，就被加载，并且只加载一次。
 * 	什么时候算第一次访问这个类？比如 new对象 或者访问这个类中的静态变量
 * 	定义位置：直接在类内部
 * 	这个东西干啥用？
 * 	静态代码块和普通代码块都可以用于执行一些前置的操作？ 
 * 	比如连接数据库  初始化数据 
 * @author WHD
 *
 */
public class TestStaticCode {
	static int num = 20;
	static {
		System.out.println("静态代码块1");
	}
	
	static {
		System.out.println("静态代码块2");
	}
		
	{
		System.out.println("普通代码块1");
	}
	{
		System.out.println("普通代码块2");
	}
	
	
	
	
	
	public static void main(String[] args) {
//		new对象肯定要加载类的
		TestStaticCode tsc1 = new TestStaticCode();
		TestStaticCode tsc2 = new TestStaticCode();
		TestStaticCode tsc3 = new TestStaticCode();
//		System.out.println(TestStaticCode.num);
	}
	
}

1.4 static关键字总结

访问：

静态与静态之间本类中可以直接访问 不同类通过类+点访问

静态访问非静态的 必须先创建对象 回顾我们写的main方法 必须先new对象

非静态的访问静态 直接访问（因为静态是先存在的 当有对象的时候 肯定类已经被加载了）

定义：

静态变量 只能定义在类中

静态方法 只能定义在类里边

静态代码块 只能定义在类里边

2.继承

2.1继承

继承有好的有坏的，如public，protect，默认不写，等三种类型的属性和方法，都可以被子类继承，但是属于private的属性和方法不能被继承。

2.2继承方法

类名 + extends + 被继承的类名

父类

package com.qfedu12;

public class Pet {
	private String name;
	private int age;
	private int heath;
	private int love;
	
	//无参构造函数
	public Pet(){};
	
	//有参构造函数
	public Pet(String name,int age,int heath,int love) {
		this.name = name;
		this.age = age;
		this.heath = heath;
		this.love = love;
	}
	//set + 属性名	赋值	公开方法
	public void setName(String name) {
		this.name = name;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public void setHeath(int heath) {
		if(this.heath >= 0) {
			this.heath = heath;			
		}else {
			System.out.println("输入的健康值不能小于0");
		}
	}
	public void setLove(int love) {
		this.love = love;
	}
	
	//get + 属性名	获取值	公开方法
	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
	public int getHeath() {
		return heath;
	}
	public int getLove() {
		return love;
	}
	
	public void print() {
		System.out.println("宠物的名字：" + name);
		System.out.println("属性：" + age);
		System.out.println("健康值：" + heath);
		System.out.println("爱心值：" + love);
	}
	
}

子类1 Dog

package com.qfedu12;

public class Dog extends Pet{
	private String species;
	
	Dog(){}
	Dog(String name,int age,int heath,int love,String species){
		super(name, age, heath, love);
		this.species = species;
	}
	public void setSpecies(String species) {
		this.species = species;
	}
	
	public String getSpecies() {
		return species;
	}
	
}

子类2 Penguin

package com.qfedu12;

public class Penguin extends Pet {
	private char sex;
	
	Penguin(){}
	Penguin(String name,int age,int heath,int love,char sex){
		super(name, age, heath, love);
		this.sex = sex;
	}
	
	public void setSex(char sex) {
		this.sex = sex;
	}
	
	public char getSex() {
		return sex;
	}
	
}