java小基础

构造器即构造函数（构造方法），构造函数实质上是具有返回值的，其返回值相当于一个地址

方法的重载即方法名相同，函数的参数（类型、个数、顺序）不同

继承即子类继承父类非私有的属性

例子：

<span style="font-size:18px;">//方法的重载
package com.huaxin.lesson0304;

public class lesson{
public String name;
//构造函数的重载
lesson (){
System.out.println("我上了第一节课");
}//构造函数的参数可有可无，其参数是为了初始化对象的属性
 lesson(String n){
 name=n;
System.out.println("我上了一节"+name+"课");
}
//方法的重载,方法的重载与方法的返回值无关
public int teach(int a){
		System.out.println("执行教学方法1");
		return a;
	}
	public void teach(){
		System.out.println("执行教学方法2");
	}
	public void teach(String n){
		System.out.println("执行教学方法2");
	}
	public void teach(String n,int a){
		System.out.println("执行教学方法2");
	}
	public void teach(int a,String n){
		System.out.println("执行教学方法2");
	}
}</span>

<pre name="code" class="html"><span style="font-size:18px;">//Student类为父类
package com.huaxin.lesson0304;

public class Student {
	public String name;
	public int number;
	Student (){
		System.out.println("父类无参构造函数被调用");
		}
    Student(String n,int a){ 
		name = n;
		number = a;
		System.out.println("name"+name+"  "+"number"+number);
		System.out.println("父类的有参构造函数被调用");
		
		}
		public void Study(){
		System.out.println("好好学习，天天向上");
		}
		
}
</span>

<span style="font-size:18px;">//继承；UnionStudent类继承Student类
package com.huaxin.lesson0304;

public class UnionStudent extends Student{
	//调用子类的无参构造函数
	public int age;
	UnionStudent(){
		super("张三",2014435110);//显式的声明调用父类的有参构造函数
	System.out.println("子类无参构造函数被调用");
	}
	//子类有参构造函数，没有显式的声明调用父类的构造函数，系统默认调用父类的无参构造函数
	UnionStudent(int n){
		age = n;
		System.out.println("子类有参构造函数被调用");
		System.out.println("age = "+age);
	}
}
</span>

<span style="font-size:18px;">package com.huaxin.lesson0304;

public class Test {
	public static void main(String[] args) {
	//创建对象，调用构造方法
	lesson les= new lesson("English");
    les.teach();
    UnionStudent us = new UnionStudent();
    us.Study();//子类调用父类继承过来的非私有的方法
 	us.age = 18;
 	System.out.println("age = "+us.age);
 	//调用父类的有参构造函数
 	UnionStudent us1 = new UnionStudent(19);
	}
}</span>

构造器、方法重载和继承是Java语言的编程中组基础的部分，也是比较容易掌握的知识点，但也有很多细节需要注意，这些细节在当你进行实践的时候才能发现，基础的东西也容易出现错误，当把一系列知识点都串起来的时候很多问题都随之而来了，因此将每个基础部分学扎实是关键。

1、方法的重写

在子类继承了父类的前提下，在子类中定义一个和父类方法相同的（方法名、参数、返回值类型）的方法，构造函数不能被继承，所以构造函数不能被重写，注意区别于方法的重载

例子：

package com.huaxin.lesson0305.test;
//学生类为父类
public class Student {
	//方法的重载
public void Study(){
	System.out.println("学生学习");
}
public void Study(String n){
	System.out.println(n+"学生努力学习");
}
}

package com.huaxin.lesson0305.test;
//大学生类作为子类继承学生类
public class UNStudent extends Student{
	//方法的重载
	public void  Study(){
		System.out.println("大学生学习");
	}
public void Study(String n){
	System.out.println(n+"大学生学习");
}
}

package com.huaxin.lesson0305.test;

public class Test {
public static void main(String[] args){
	UNStudent uns = new UNStudent();//创建一个大学生对象
	uns.Study();//调用大学生类重写的Study（）方法
	uns.Study("张三");//调用大学生类重写的Study（String n）方法
}

}

2、自动转型

定义：创建子类的对象，然后自动转型为父类的类型
格式：父类类名  对象名  = new  子类类名();
3.多态
体现：多个同一种类型的对象，执行同一个方法，执行的过程不一样(有区别)


为什么会有多态现象？因为存在自动转型和方法重写两种情况同时存在（进行）的情况  

自动转型和方法重写同时存在的前提是继承

例子:

package com.huaxin.lesson0305.test;
//学生类为父类
public class Student {
	//方法的重载
public void Study(){
	System.out.println("学生学习");
}
public void Study(String n){
	System.out.println(n+"学生学习");
}
}

package com.huaxin.lesson0305.test;
//大学生类作为子类继承学生类
public class UNStudent extends Student{
	//方法的重载
	public void  Study(){
		System.out.println("大学生学习");
	}
public void Study(String n){
	System.out.println(n+"大学生学习");
}
}

package com.huaxin.lesson0305.test;

public class Test {
public static void main(String[] args){
	Student st = new Student();//创建一个学生对象
	UNStudent us = new UNStudent();//创建一个大学生对象
	Student uns = new UNStudent();//创建一个大学生对象,自动转型
	st.Study();//没有转型，会调用类本身的方法
	st.Study("李四");
	us.Study();
	us.Study("王五");
	uns.Study();//自动转型后调用大学生类重写的Study（）方法
	uns.Study("张三");//自动转型后调用大学生类重写的Study（String n）方法
}

}

4.方法分类（构造方法、普通方法、抽象方法）

格式：
构造方法：public 类名(){}

普通方法：public 返回类型  方法名(参数){}
抽象方法：public abstract 返回类型 方法名(参数);

5.类的分类（普通类、抽象类、接口）
普通类：public class 类名{}
1.只能有普通方法和构造方法，一定不能有抽象方法
2.可以创建对象（由以上解释已证）
3.属性可以是常量（用static final修饰），也可以是变量

例子：

抽象类：public abstract class 类名{}
1.三种类型的方法都可以存在
2.不能创建对象
3.属性可以是常量（用static final修饰），也可以是变量

例子：

接口：public interface 类名(){}
1.只能有抽象方法，普通方法和构造方法不存在
2.不能创建对象
3.属性一定是常量（用static final修饰）
例子：

6.接口继承
接口和抽象类的作用是被用来当作父类继承的，抽象方法是用来指导子类重写(实现)的。
关键字：implements 
格式：public class 子类类名  implements 接口名{
//重写父类的所有的抽象方法
}
接口相当于领导，只负责指导开发。

例子：

package com.huaxin.lesson0305.test;
//学生接口为父类，被继承
public interface Student {
	static final String   b="aa";//接口中的属性只能是常量
public abstract void Study();//接口中只能存在抽象方法
}

package com.huaxin.lesson0305.test;
//大学生类作为子类继承学生接口
public class UNStudent implements Student{
	//重写父类接口等呃所有抽象方法，即父类的抽象方法指导子类重写方法
	public void Study(){
		System.out.println("好好学习，天天向上");
}
}

package com.huaxin.lesson0305.test;

public class Test {
public static void main(String[] args){
	UNStudent us = new UNStudent();//创建一个大学生对象
	us.Study();
}
}

看似简单的基础就越容易出错，还是扎扎实实地掌握基础和细节才能融会贯通呀，嗯，加油吧！