重载-day02

重载

1.1含义

在同一个类下,方法名相同,参数列表不同,我们称之为方法的重载
注意:
1.一定是在同一个类下
2.与返回值类型无关
3.重载和方法体无关
4.参数列表不同不是指参数名字不同,而是指他的类型或者类型顺序不同

class A{
	public void run() {
		
	}
	private void run(String name) {
		
	}
	void run(String name,int age) {
			
			}
	void run(int m,String n) {
		
	}
}

重写

1.含义

发生在父子类之间,遵同两同两小一大原则

两同:方法名称相同,参数列表相同
两小:
1.子类的返回值类型要小于父类
1.1)返回值类型如果是基本类型 必须相同
1.2)返回值类型如果是引用类型 小于/等于
Object 类他是所有类的一个超类(祖宗类)
2.子类所抛出的异常要小于父类
一大:子类的访问权限修饰符要大于父类
public>protected>default>private

构造方法

1. 什么是构造方法?

含义:构造方法是一种特殊的方法,他是一种方法名与类名相同,且没有返回值的方法(是连void都没有的方法)

构造方法也叫构造器,也叫构造函数,它的作用是什么呢?
作用:当创建对象的时候自动调用相对应的构造方法
初始化成员变量属性

注意:
1.构造方法可以重载
2.如果类中没有构造方法,系统会默认提供一个无参构造方法
3.如果已经显示的写出了一个有参构造,它会将系统默认提供的无参构造方法进行覆盖(如果想创建无参构造对象,需要显示的写出无参构造)
结构:
修饰符 类名即方法名(有参/无参){
方法体
}

public class constructionDemo {
	String name;
	int age;
	//无参构造方法
	public constructionDemo() {
		System.out.println("调用了constructionDemo的无参构造方法");
	}
	public constructionDemo(String name,int age) {
		//this.name 为实参也就是成员变量      name为形参  形式参数  局部变量
		this.name=name;
		this.age=age;
		System.out.println("调用了constructionDemo的有参构造方法");
	}
	//需要get set 方法了  封装属性
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public static void main(String[] args) {
		constructionDemo cd =new constructionDemo();
		constructionDemo cd1=new constructionDemo("张三", 18);
		System.out.println(cd1.name);
		System.out.println(cd1.age);
		
		constructionDemo cd2=new constructionDemo();
		cd2.setName("李四");
		cd2.setAge(20);
		System.out.println(cd2.name);
		System.out.println(cd2.age);
	}
	
	

}

this关键字

含义:指代的是本类对象的一个引用
**注意:**如果在构造方法中,this()必须放在第一行

package day02;
//this演示
public class Animal {
	String name;
	public void run(String name) {
		this.name=name;
		//Animal.name=name;
	}
	//如果局部变量的名称和成员变量的名称相同时
	//根据java的就近原则,他会找离他最近的一个变量名
	//所以我们用this来进行指向
	
//	public void run(String n) {
//		name=n;
//	}
	public static void main(String[] args) {
		Animal a=new Animal();
		a.run("大黄");//name 大黄
		System.out.println(a.name);
		
		Animal a1=new Animal();
		a1.run("小红");//name 小红
		System.out.println(a1.name);
		
	}
	
}

当局部变量和成员变量重名时,使用this关键字来进行解决
如果局部变量和成员变量重名,java会根据就近原则,选择离他最近的一个变量相当于name=name

this在构造方法之间的用法

this()必须放在构造器的第一行

package day02;
//this演示2
public class dog {
	public dog() {
		this("旺财");  //dog("旺财")
		System.out.println("调用了狗类的无参构造");
	}

	public dog(String name) {
		System.out.println(name);
	}
	public static void main(String[] args) {
		dog d=new dog();
	}
}

继承

继承是我们面向对象的特征之一(封装,继承,多态,抽象)
含义:继承是指从已有的实现类中派生出新的类,新的类拥有已有的实现类中的数据的功能和行为,并且实现自己类独有的特性,增加了代码的扩展性

1.继承是使用extends关键字
2.继承是相当于将父类中的数据功能复制给子类一份
3.继承存在着单一性,就是单一继承,即一个子类只能有一个父类 但是一个父类可以有多个子类
4.继承存在着传递性
5.继承不能继承父类的私有属性和方法
6.继承主要是用于代码的扩展(向上造型 重写)

package day02;
//继承的演示
public class inheritDemo {
	public static void main(String[] args) {
		Zi z=new Zi();
		System.out.println(z.name);
		System.out.println(z.addr);
		z.sing();
//		System.out.println(z.age);
//		z.run();
//		向上造型
		Fu f=new Zi();
		f.eat();
//      父类的私有方法不能重写
	}
}
class Fu{
	private int age=20;
	String name="黄种人";
	String addr="成都";
	public void sing() {
		System.out.println("和我在成都的街头走一走");
	}
	private void run() {
		System.out.println("随风奔跑*是方向");
	}
	private void eat() {
		System.out.println("爸爸吃饭了");
	}
}
class Zi extends Fu{
	//子类可以继承父类的属性和行为,但是不能继承私有的属性和行为
	//父亲也需要有一些小秘密
	public void eat() {
		System.out.println("儿子吃饭了");
	}
}

**注意:**父类的所有东西都能被继承过来,除了私有的(每个人都有点小秘密)
父类的私有方法不能被重写

Super

概念:在Java中一般都是指向父类对象的一个引用
//先有爹 后有儿子
1.main里面创建B对象
2.自动调用与其匹配的构造方法
3.我们要创建子类对象,但是还没有父类
所以无参构造方法B第一行隐式的有一个super();
指向父类的无参构造方法来初始化父类的成员

注意:super必须放在构造方法的第一行
原因和this是一样

super和this的区别

1.this指代的是本类对象的引用 super是父类对象的引用
2.this是用来区别局部变量和成员变量的
3.super是用来区别父类对象和本类对象的
4.this和super可不可以出现在同一个构造函数中
注意:
1.this()和super()不能出现在同一个构造函数中

package day02;
//Super演示2
public class SuperDemo2 {
	public SuperDemo2() {
		this("王鹏力");
		super();
		
	}
	public SuperDemo2(String name) {
		
	}
}

2.super()可以和this.属性放在同一个构造函数中

package day02;
//Super演示2
public class SuperDemo2 {
	String name;
	public SuperDemo2() {
		
	}
	public SuperDemo2(String name) {
		super();
		this.name=name;
	}
}

static

静态的
含义:static是我们java的一个关键字 代表静态的
作用:修饰成员的(成员变量和成员方法)
特点
1.修饰成员的(成员变量和成员方法)
2.随着类加载而进行加载 优先于对象加载
3.只加载一次 就会一直存在 不会开辟新的空间
4.全局唯一 全局共享
5.可以通过类名来调用
6.静态的东西只能访问静态的,非静态的可以随意访问
7.static不能和this/super一起使用,因为有static的时候可能还没有对象产生

package day02;
//static演示
public class staticDemo {
	static {
		System.out.println("static代码块已加载");
	}
	public static void main(String[] args) {
		int i=Student.age;
		System.out.println(i);
		
		Student s=new Student();
		Student s1=new Student();
		System.out.println(s.name);
		System.out.println(s.age);//18
		System.out.println("----------");
		System.out.println(s1.age);//?18
		s1.age=20;
		System.out.println(s.age);//20
		
	}
}
class Student{
	String name="王鹏力";
	static int age=18;
	
	public void eat() {
		System.out.println("eat....");
	}
	public static void speak() {
		System.out.println("speak....");
	}
}

静态的调用关系

静态的东西只能访问静态的,非静态的可以随意访问
静态的只能访问静态的东西(变量和方法) 非静态的可以访问所有的东西,不管他是不是静态的

package day02;

public class staticDemo2 {
	public static void main(String[] args) {
		Teacher t=new Teacher();
		t.speak();
	//  t.run();
	}
}
class Teacher{
	String name="张三";
	static int age=18;
	public void speak() {
		System.out.println(name);//非静态能调用非静态变量
		System.out.println(age);//非静态能调用静态变量
	}
	public static void run() {
	//	System.out.println(name);//静态不能调用非静态的变量
		System.out.println(age);//静态的能调用静态的变量
	}
}

静态代码块

随着类的加载而加载,并且只加载一次,一般用于项目的初始化(初始化图片)
static{
…
}