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();
}
}

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