java面向对象-构造器-方法的重载--继承

1.构造器–(构造方法—构造函数)

1.1.什么是构造器?

1.1构造器也称为–(构造方法–与—构造函数)是定义在Java类中的一个用来初始化对象的(函数)!
1.2使用new+构造方法 创建一个新的对象
1.3构造函数与类同名且没有返回值也没有void
例如:Student one=new Student();
解析:Student为类 one对象名=new创建 Student();//构造器–(构造方法—构造函数)这样就创建了一个新的对象;

//无参构造器(构造方法--构造函数)
语法格式:  public 类名(){
}  

//有参构造器(构造方法--构造函数)
语法格式:  public 类名(类型,属性名){
this.属性名=属性名;
}  

代码演示:

//创建类
public class Cat {
    //姓名
    String name;
    //年龄
    int age;
    //有参构造器
    public Cat(String name,int age){
        this.name=name;
        this.age=age;
        //为了看到效果我这里输出一下
        System.out.println("姓名"+this.name+"年龄"+this.age);
    }
    //无参构造器
    public Cat(){
    }
}

-----测试类----

//创建类
public class CatTest {
    //启动  主函数
    public static void main(String[] args) {
           Cat one=new Cat("小花",12);
    }
}

• 运行结果:
  
  1.为什么会得到这么一个结果呢?
  肯定是有谁输出/打印了,谁输出呢?
  就是我们的构造器里面的输出/打印了那么就说明Cat这个方法被执行了
  Cat是什么方法呢?
  它就是一个构造器也称为构造方法或者构造函数
  2.在用类创建一个对象就new加上它的构造方法,调用构造器之后,构造器里面的方法肯定会被执行!
  所以得到这么一个结果

用一个类创建对象的时候实际上就是在new它的构造器(构造方法—构造函数),
那为什么我们以往写的程序里并没有构造器却还可以去声明对象呢?

因为:在运行程序的时候如果没有写构造器java编译器会自动的默认给你一个无参构造器所以你可以调用.但是它不会执行什么操作直接创建一个对象出来,当属性没有被赋值的时候! 打印属性的时候都是默认值

• 代码演示:

public class Cat {
    //姓名
    String name;
    //年龄
    int age;
    }

//创建类
public class CatTest {
    //启动  主函数
    public static void main(String[] args) {
        Cat one=new Cat();
        System.out.println("name:"+one.name+"\tage:"+one.age);
    }
}

• 运行结果:
• 
  可以看到没有在类中写构造器但它依旧可以运行原因就是因为java编译器会自动的默认给你一个无参构造器
• 当无参构造器和有参构造器一起使用呢?

 //创建类
public class Cat {
    //姓名
    String name;
    //年龄
    int age;

    //有参构造器
    public Cat(String name,int age){
        this.name=name;
        this.age=age;
    }
    //普通的一个打印方法
    public void get(){
        System.out.println("姓名"+this.name+"年龄"+this.age);
    }
    //无参构造器
    public Cat() {
    }
}

//创建类
public class CatTest {
    //启动  主函数
    public static void main(String[] args) {
        Cat one=new Cat();
        one.get();
        Cat tow=new Cat("小花",12);
        tow.get();

    }
}

运行结果:

• 注意如果想同时调用无参和有参构造器的时候必须二个都要写!
• 如果只写了有参的构造器却调用无参构造器那么程序报错!
• 写了无参的没有写有参的在调用构造器里写了参数那么程序也会报错!
• 构造器必须与类名同名且不能有返回值也不能写void,public可以省略!

2.方法的重载

2.1什么是方法的重载?

方法的重载是指一个类中可以定义有相同的名字,但参数不同的多个方法,调用时会根据不同的参数列表选择对应的方法!
简称方法名相同,参数不同就称之为方法的重载
代码演示:
//创建类

public class Student {
    //定义一个普通 有参方法 求最大值
    public void max(int a,int b){
        //定义一个三元运算符做比较  大于则返回a小于则返回b
        System.out.println(a>b?a:b);
    }
}

//创建类
public class StundentText {
//主函数
    public static void main(String[] args) {
    //创建对象
        Student one=new Student();
        //调用方法传入参数
        one.max(7,4);
    }
}

运行结果

7

那么我想用小数做比较呢?
很显然是不可以的,因为定义的值是要int类型的而小数是double类型程序会报错
如果非要比较就只能强制转换,但会出现精度丢失的问题
那我在定义一个方法不就好了?
代码演示:

//创建类
public class Student {
    //定义一个普通 有参方法 求最大值
    public void max(int a,int b){
        //定义一个三元运算符做比较  大于则返回a小于则返回b
        System.out.println(a>b?a:b);
    }
    public void maxDouble(double a,double b){
        System.out.println(a>b?a:b);
    }
}

//创建类
public class StundentText {
//主函数
    public static void main(String[] args) {
    //创建对象
        Student one=new Student();
        //调用方法传入参数
        one.maxDouble(6.9,5.8);
    }
}

运行结果

6.9

那万一我要比较三个数字,比较四个 ,求最大,求最小.求和…等等一些操作呢?
是不是就要写很多很多方法这是不是让代码变的复杂而且也不好去记相对于的方法名!
这时候就需要方法的重载了!

2.2使用方法重载

方法的重载,同名不同参
代码演示:

//创建类
public class Student {
    //定义一个普通 有参方法 求最大值
    public void max(int a,int b){
        //定义一个三元运算符做比较  大于则返回a小于则返回b
        System.out.println("第一个方法最大值"+(a>b?a:b));
    }
    //方法的重载
    public void max(double a,double b){
        System.out.println("第二个方法最大值"+(a>b?a:b));
    }
}

//创建类
public class StundentText {
//主函数
    public static void main(String[] args) {
    //创建对象
        Student one=new Student();
        //调用方法传入参数
        one.max(7.5,5.8);
    }
}

运行结果:

第二个方法最大值7.5

这里可以看到运行的第二个方法,怎么运行的呢?
调用时会根据不同的参数列表选择对应的方法!可以看到我传的是小数7.5和5.8那么就会选择对应的方法进行比较
试试比较三个呢?
代码演示:

//创建类
public class Student {
    //定义一个普通 有参方法 求最大值
    public void max(int a,int b){
        //定义一个三元运算符做比较  大于则返回a小于则返回b
        System.out.println("第一个方法最大值"+(a>b?a:b));
    }
    //方法的重载
    public void max(double a,double b){
        System.out.println("第二个方法最大值"+(a>b?a:b));
    }
    //方法的重载
     public void max(double a,double b,double c){
     //相比较a与b谁大   赋值给max
        double  max=a>b?a:b;
        //再用max的值与c做比较
        System.out.println("第三个方法最大值"+(max>c?max:c));
    }
}

//创建类
public class StundentText {
//主函数
    public static void main(String[] args) {
    //创建对象
        Student one=new Student();
        //调用方法
        one.max(7.5,4.2,7.2);
    }
}

运行结果

第三个方法最大值7.5

这里可以看到我传了3个参数所以调用了第三个方法,
这便是方法的重载不需要在记方法名了只需根据传进来的参数就会自动调用对应的方法了!

3.什么是继承?

• 在了解继承之前我们先来看二段代码:

//创建类
public class Teather {
    //创建二个属性(变量)
    //姓名
    String name;
    //年龄
    int age;
//创建一个普通方法
    public void teath() {
        System.out.println("教书");
    }
}

//创建类
public class Student1 {
    //创建二个属性(变量)
    //姓名
    String name;
    //年龄
    int age;
    //创建一个普通方法
    public  void study(){
        System.out.println("学习");
    }
}

• 在两个类中可以看到其中都有name和age这样如果我要写100个职业其中都有姓名和年龄那且不是要写100个name和age?这样是不是显得很麻烦!
• 可以看到二个类中都有共性的描述,
• 那能不能提取出来单独的写一个类与这两个类建立关系
• 但不能平白无故的写一个类把nama和age放在里面,肯定要符合
• 可以看到学生和老师都是属于人类,就可以创建一个人类把学生和老师共性的描述放在里面且与学生和老师类建立关系
• 学生类和老师类与人类建立了关系那么里面也就都有对应的属性了
• 这种关系呢也就称为–继承关系—继承
• 继承:定义类是对现实生活中的描述 那现实中的描述也有关系 事物对事物之间的关系,例如:爹与儿子的关系–老板与员工…,而继承关系也就是其中的一种

3.1.继承的语法格式

• 语法格式;子类 extends --(父类)
• 代码演示:

 //创建类
public class Person {
    //姓名
    String name;
    //年龄
    int age;
}

//创建类
public class Student1 extends Person{
    //创建一个普通方法
    public void study() {
        this.name="小明";
        System.out.println(this.name+"在学习");
    }
}

//创建类
public class Teather  extends Person{
//创建一个普通方法
    public void teath() {
        this.name="王老师";
        this.age=18;
        System.out.println(this.name+"今年有"+this.age+"岁了");
    }
}

//创建类
public class Text {
    //主函数
    public static void main(String[] args) {
        Student1 one=new Student1();
        one.study();
        Teather one1=new Teather();
        one1.teath();
    }
}

运行结果:

小明在学习
王老师今年有18岁了

继承简称:子承父业—子承父类
Student和Teather就是Person的子类
Person就是Stundent和Teather的父类(超类,基类)

3.2.继承的概况

1.提高了代码的复用性,简化了代码
2.让类与类之间产生了继承关系,才有了后面的多态特性的存在
注意
千万不要为了获取其他类的功能简化代码,而建立继承关系!
必须要类与类之间存在继承关系,继承关系:is a(is a可以理解我是你的)
例如:猫和猫科那么猫和猫科就可以建立继承的关系 总不能猫与犬科建立继承关系吧!因为猫都不是犬科的所有不能建立继承关系

3.3.父类

父类就是将子类里有共同的描述或特性抽取出来放在里面的这样父类才存在的!
例如:猫和豹子和老虎它们都是属于猫科,猫科就是特性可以抽取出来放在父类里面

3.4.继承的概念_2

子类拥有父类的成员,但子类不能拥有父类中被private修饰后的成员
没有被private修饰:代码演示:

//创建一个猫科类
public class MaoKe {
    //成员变量
        String name;
        //创建一个普通方法
       public void eat(){
           //输出打印
            System.out.println(this.name+"是猫科");
    }
}

//创建一个豹子类并继承猫科类
public class Leopard extends MaoKe{
    //创建一个普通方法
    public void run(){
        //输出打印
        System.out.println(this.name+"正在奔跑");
    }
}

//创建一个猫类并继承猫科类
public class Cat extends MaoKe{
    //创建一个普通的方法
    public void catchMouse(){
        System.out.println(this.name+"正在捕鼠");
    }
}

//创建一个测试类
public class Text {
    //主函数
    public static void main(String[] args) {
        //new一个对象
        Cat cat=new Cat();
        //调用父类的成员
        cat.name="猫咪";
        //调用方法
        cat.eat();
        //调用方法
        cat.catchMouse();
        //换行
        System.out.println();
        //new一个对象
        Leopard leopard=new Leopard();
        //调用父类的成员
        leopard.name="豹子";
        //调用方法
        leopard.eat();
        //调用方法
        leopard.run();
    }
}

注意!当子类里没有对应的方法的时,则会去调用父类里的方法
运行结果:

猫咪是猫科
猫咪正在捕鼠

豹子是猫科
豹子正在奔跑

• 可以看到不仅仅是打印了子类里的方还打印了父类里的方法!
• 如果用private修饰呢?
  
  
  
• 可以看到当被private修饰后 子类无法访问父类的方法或者成员!

3.5.多层继承

• 多层继承概念

• 在多层继承中最下层的子类拥有整个继承体系的成员

• 看思维导图

• 

• 例如:豹子>猫科类>哺乳类>动物类

• 豹子继承了猫科类继承了哺乳类继承了动物类

• 那么豹子作为最下层的子类则拥有整个继承体系的成员与方法!

• 代码演示:

//创建一个哺乳类
public class Lactation {
    //创建成员
    String name;
    //创建一个普通的方法
    public void lactation(){
        System.out.println(this.name+"是哺乳类");
    }
}

//创建一个猫科类并继承哺乳类
public class MaoKe extends Lactation {
        //创建一个普通方法
       public void eat(){
           //输出打印
            System.out.println(this.name+"是猫科");
    }
}

//创建一个猫类并继承猫科类
public class Cat extends MaoKe{
    //创建一个普通的方法
    public void catchMouse(){
        System.out.println(this.name+"正在捕鼠");
    }
}

//创建一个豹子类并继承猫科类
public class Leopard extends MaoKe{
    //创建一个普通方法
    public void run(){
        //输出打印
        System.out.println(this.name+"正在奔跑");
    }
}

//创建一个测试类
public class Text {
    //主函数
    public static void main(String[] args) {
        //new一个对象
        Cat cat=new Cat();
        //调用父类的成员
        cat.name="猫咪";
        //调用方法
        cat.lactation();
        //调用方法
        cat.eat();
        //调用方法
        cat.catchMouse();
        //换行
        System.out.println();
        //new一个对象
        Leopard leopard=new Leopard();
        //调用父类的成员
        leopard.name="豹子";
        //调用方法
        leopard.lactation();
        //调用方法
        leopard.eat();
        //调用方法
        leopard.run();
    }
}

运行结果:

猫咪是哺乳类
猫咪是猫科
猫咪正在捕鼠

豹子是哺乳类
豹子是猫科
豹子正在奔跑

3.6.继承的注意点!

• Java中不支持多继承的,只支持单继承,因为多继承存在安全隐患,
• 当多个父类定义了相同的成员,子类对象不确定运行哪一个.
• 但Java保留了这种机制,并用了另外一种方式来体现,多实现!
• 代码演示多继承:
• 
  可以看到错误提示:类不能扩展多个类!
• 简单说明:一个爹可以有多个儿子,但儿子不能有多个爹!
  本章完毕