本文共 6553 字，大约阅读时间需要 21 分钟。

• 方法重写概述：子类中出现了和父类中一模一样的方法声明
• 方法重写的应用：当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父亲的功能，又定义了子类特有的内容。

练习：手机类和新手机类public class Phone {   	public void call(String name) {   		System.out.println("给"+name+"打电话");	}}

public class NewPhone extends Phone {   	@Override	public void call(String name) {   		System.out.println("打开视频功能");		super.call(name);	}}

#测试类	public static void main(String args[]) {   		//创建对象，调用方法		Phone p=new Phone();		p.call("林青霞");				System.out.println("-------------");		NewPhone np=new NewPhone();		np.call("林青霞");	}

• @Override是一个注解，可以帮我们检查重写方法的方法声明的正确性。

案例：老师和学生public class Person {   	private String name;	private int age;	public Person() {   			}	public Person(String name,int age) {   		this.name=name;		this.age=age;	}		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 class Teacher extends Person {   	public Teacher() {   }	public Teacher(String name,int age) {   //		this.name=name;//		this.age=age;		super(name,age);	}	public void teach() {   		System.out.println("教书育人");	}}

public class Student extends Person {   	public Student() {   			}	public Student(String name,int age) {   		super(name,age);	}	public void study() {   		System.out.println("好好学习，天天向上！！");	}}

#测试类	public static void main(String args[]) {   		//创建对象，调用方法		Teacher t1=new Teacher();		t1.setAge(33);		t1.setName("风清扬");		System.out.println(t1.getAge()+","+t1.getName());		t1.teach();				Teacher t2=new Teacher("ycy",30);		System.out.println(t2.getName()+","+t2.getAge());		t2.teach();				Student s1=new Student();		s1.setName("my");		s1.setAge(25);		System.out.println(s1.getName()+","+s1.getAge());		s1.study();				Student s2=new Student("tc",22);		System.out.println(s2.getName()+","+s2.getAge());		s2.study();	}

案例：猫和狗public class Animal {   	private String name;	private int age;	public Animal() {   			}	public Animal(String name,int age) {   		this.name=name;		this.age=age;	}		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 class Cat extends Animal {   	public Cat() {   }	public Cat(String name,int age) {   //		this.name=name;//		this.age=age;		super(name,age);	}	public void catchMouse() {   		System.out.println("猫抓老鼠");	}}

public class Dog extends Animal {   	public Dog() {   			}	public Dog(String name,int age) {   		super(name,age);	}	public void lookDoor() {   		System.out.println("好好看门");	}}

#测试类	public static void main(String args[]) {   		//创建对象，调用方法		Cat c1=new Cat();		c1.setName("加菲猫");		c1.setAge(5);		System.out.println(c1.getName()+","+c1.getAge());		c1.catchMouse();				Cat c2=new Cat("加菲猫",2);		System.out.println(c2.getName()+","+c2.getAge());		c2.catchMouse();				Dog d1=new Dog();		d1.setName("藏獒");		d1.setAge(10);		System.out.println(d1.getName()+","+d1.getAge());		d1.lookDoor();				Dog d2=new Dog("藏獒",22);		System.out.println(d2.getName()+","+d2.getAge());		d2.lookDoor();	}

导包的概述和使用

使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了。为了简化带包的操作，Java就提供了导包的功能。

• 导包的格式：
• import 包名;
• 范例：import cn.itcast.Teacher; import java.util.Scanner;
• 或者可以直接写在程序中
• 范例：//cn.itcast.Teacher t1=new cn.itcast.Teacher(); //创建Teacher对象 t1
• java.util.Scanner sc=new java.util.Scanner(System.in);

权限修饰符

• 修饰符的分类：权限修饰符和状态修饰符
  权限修饰符访问：

public class Fu{   	private void show1() {   		System.out.println("private");	}	void show2() {   		System.out.println("默认");	}	protected void show3() {   		System.out.println("protected");	}	public void show4() {   		System.out.println("public");	}	public static void main(String args[]) {   		//创建对象，调用方法		Fu f=new Fu();		f.show1();		f.show2();		f.show3();		f.show4();	}}

public class Zi extends Fu{   	public static void main(String args[]) {   		Zi z=new Zi();		z.show2();		z.show3();		z.show4();	}}

public class Demo{   	public static void main(String args[]) {   		Fu f=new Fu();		f.show2();		f.show3();		f.show4();	}}

final(最终态)

• final关键字是最终的意思，可以修饰成员方法，成员变量，类。

final修饰的特点

• 修饰方法：表明该方法是最终方法，不能被重写
• 修饰变量：表明该变量是常量，不能再次被赋值
• 修饰类：表明该类是最终类，不能被继承

//public final class Fu{   public  class Fu{   	public final void method() {   		System.out.println("Fu method");	}}

public class Zi extends Fu{   	public final int age=20;  //常量	public void show() {   //		age=100;  //重新赋值		System.out.println(age);	}//	public void method() {   //		System.out.println("Zi method");//	}}

public class Demo{   	public static void main(String args[]) {   		Zi z=new Zi();		z.method();		z.show();	}}

• final修饰局部变量
• 1.变量是基本类型：final修饰指的是基本类型的数据值不能发生改变。
• 2.变量是引用类型：final修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的。

public  class Student{   	public int age=20;}

public class Demo{   	public static void main(String args[]) {   		//final修饰基本类型变量		final int age=20; //常量//		age=100;		System.out.println(age);				//final修饰引用类型变量		final Student s=new Student();		s.age=100;		System.out.println(s.age);		//		s=new Student();  //s无法再次创建对象，会出错	}}

static 修饰符

static关键字是静态的意思，可以修饰成员方法，成员变量

static修饰的特点

• 被类的所有对象共享，这也是我们判断是否使用静态关键字的条件。
• 可以通过类名调用，当然，也可以通过对象名调用。推荐使用类名调用。

public  class Student{   	public String name;	public int age;//	public String university;	public static String university;  //共享成员变量		public void show() {   		System.out.println(name+','+age+','+university);	}}

public class Demo{   	public static void main(String args[]) {   				Student.university="南开大学";				Student s1=new Student();		s1.name="张三";		s1.age=20;//		s1.university="南开大学";		s1.show();				Student s2=new Student();		s2.name="李四";		s2.age=25;//		s2.university="南开大学";		s2.show();	}}

static访问特点

非静态的成员方法

• 能访问静态的成员变量
• 能访问非静态的成员变量
• 能访问静态的成员方法
• 能访问非静态的成员方法

静态的成员方法

• 能访问静态的成员变量
• 能访问静态的成员方法

public  class Student{   	//非静态成员变量	private String name="张三";	//静态成员变量	private static String university="南开大学";		//非静态成员方法	public void show1() {   			}		//非静态成员方法	public void show2() {   		System.out.println(name);		System.out.println(university);		show1();		show3();	}		//静态成员方法	public static void show3() {   			}		//静态成员方法   (main方法是静态的，所以方法都用静态修饰)	public static void show4() {   //		System.out.println(name);		System.out.println(university);//		show1();		show3();	}}

总结：静态成员方法只能访问静态成员。

相关来源：https://blog.csdn.net/weixin_42400413/article/details/83217937