第32节:Java中-构造函数,静态方法,继承,封装,多态,包

标题图

构造函数实例

class Cat{
 // 设置私有的属性 name
private String name;
   // 设置name的方法
    public void setName(String Name) {
    this.name = Name;
    }
  // 设置获取name的方法
    public String getName() {
        return this.name;
    }

    // 设置不带参数的构造方法
    public Cat() {
        System.out.println("This is a cat");
    }

    // 设置带参数的构造方法
    public Dog(String Name) {
        this.name = Name;
        System.out.println("This is a cat "+name);
    }
   // 定义一个方法
    public void sleep(){
     System.out.println(this.name+ "is sleeping");
    }
}

测试类

// 测试类
class CatTest {
    public static void main(String[] args) {
        // 定义对象
        Cat cat1 = new Cat();
        cat1.setName("buling");
        cat1.sleep();

        Cat cat2 = new Cat("LiLi");
        cat2.sleep();
    }
}

静态方法

class Demo {
  // 定义一个函数
    public void fun1() {
        System.out.println("Hello");
    }
    // 定义一个静态函数
    public static void fun2() {
        System.out.println("hello");
    }
}

public class DemoTest {
    public static void main(String[] args) { 
      // 创建对象
      Demo d = new Demo();
      d.fun1();
      // 对静态函数进行调用
      Demo.fun2();
      
      // 创建对象
      Demo d2 = new Demo();
      d2.fun2();
    }
}

静态修饰的调用方式:1)类名.方法名;2)对象.方法名

继承

案例

在现实世界当中,继承就是儿子得到老子的东西,在面向对象的世界当中,继承就是一个类得到了另一个类当中的成员变量和成员方法

Java只支持单继承,不允许多继承,继承是为了减少重复代码

使用super调用父类构造函数的方法

class Person{
// 定义属性
String name;
int age;
// 无参构造函数
Person(){
 System.out.prinltn("Person的无参数构造函数");
}
// 有参的构造函数
Person(String name,int age){
 this.name=name;
 this.age=age;
 System.out.println("Person有参数的构造函数");
}
// 定义的方法
void eat(){
 System.out.println("定义吃饭的方法");
}
}
class Student extends Person{
//子类继承父类
Student(){
 //父类
 super();
 System.out.println("Student的无参数构造函数");
}
Student(String name,int age,int id){
 super(name,age);
 this.id=id;
}
}

Java中的继承,其实就是继承全部属性和方法(除了构造方法),除了private修饰的变量或者方法,子类无法进行访问

格式:

[类修饰符] class 子类名 extends 父类名{  ... ...}

如:

class Student extends People{  ... ...}

类的继承:Object->People->Student

Java中的类只支持单继承,不支持多继承。

类成员的继承:

对于继承:一个类中有成员变量和方法。 子类继承父类,可以有部分继承它的父类,也可以自己定义。

子类能继承publicprotected的成员变量,不能继承private的成员变量,可以继承同包中的默认修饰符。

同理,子类继承父类的方法,能够继承publicprotedted的方法,不能继承private的方法,不能继承构造方法。

封装

封装为了提稿代码的复用性,隐藏了实现的细节,提供对外的访问。

// 老婆类
class Woman {
    // 定义属性
    private String name;
    private int age;
   // 私有丈夫
    private Man husband;

    // 获取老婆名字
    public String getName() {
        return name;
    }
    // 设置老婆名字
    public void setName(String name) {
        this.name = name;
    }

    // 设置老婆年龄
    public void setAge(int age) {
        this.age = age;
    }
    // 获取老婆年龄
    public int getAge() {
        return age;
    }
    // 设置丈夫
    public void setHusband(Man husband) {
        this.husband = husband;
    }
    // 获取男人,返回男人类
    public Man getHusband() {
        return husband;
    }       
}
// 男人类
public class Man {
    // 私有化名字
    private String name;
    // 私有化年龄
    private int age;
    // 私有化老婆
    private Woman wife;

    // 设置名字
    public void setName(String Name) {
        this.name = Name;
    }
    // 获取名字
    public String getName() {
        return this.name;
    }
    // 设置年龄
    public void setAge(int Age) {
        this.age = Age;
    }
    // 获取年龄
    public int getAge() {
        return this.age;
    }
    // 设置老婆
    public void setWife(Woman wife) {
        this.wife = wife;
    }
}

可将这两种方法进行封装。

多态

多态是为了提高功能的扩展性,提高复用,为父类的引用指向了子类的对象,多态,多种形态的体现。

父类引用指向子类对象,并调用子类的覆盖方法,就是多态,注意父类的引用不能随便强加转为子类类型,因为强转可能会出错,在转换前先使用instanceof判断父类是否可以转换为子类

abstract class Animal{
 public abstract void eat();
}

多态原理:

Dog d = new  Dog();
Animal a = new Dog();
Cat c = new Catt();
Animal aa = new Cat();

多态是同一种行为的不同表现形式或形态的能力。

多态步骤

  1. 有继承关系;
  2. 子类要重写父类的方法;
  3. 父类要指向子类的引用

案例

// 抽象动物类
abstract class Animal {  
   // 抽象的方法
    abstract void eat();  
}  
  // 子类继承父类
class Cat extends Animal {  
    // 重写了父类的方法
    public void eat() {  
        System.out.println("吃鱼~");  
    }  
   // 添加了功能
    public void work() {  
        System.out.println("抓老鼠~");  
    }  
}  
  // 子类继承了父类
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头~");  
    }  
  // 添加了自己的功能
    public void work() {  
        System.out.println("看家~");  
    }  
}
// 测试类
public class DemoTest {
    public static void main(String[] args) {      
     // 父类指向子类的对象
     // 向上转型  
      Animal a = new Cat();     
     // 调用 Cat 的 eat方法
      a.eat();           
     // 现行判断     
      if(a instanceof Cat) {
        // 向下转型
        Cat c = (Cat)a;  
       // 调用 Cat 的 work  方法     
        c.work();               
      } else if(a instanceof Dog) {
          Dog d = (Dog)a;
          d.work();
      }
  }  
}

java中提供了不同的类和接口存放在不同的包中。

常见的包

java.applet
java.awt
java.net
java.util
java.lang
java.io

包的格式:

package 包名[.子包名[…]];

引入java

import  包层次结构的类名;

Java package提供了访问权限和命名的管理机制,是Java中非常重要的一个概念。为了使包名保持唯一性,通常采用小写、按倒写公司网址的形式进行定义;避免使用与jdk提供的包发生冲突的名字。

结语

  • 本文主要讲解 Java中-构造函数,静态方法,继承,封装,多态,包
  • 下面我将继续对JavaAndroid中的其他知识 深入讲解 ,有兴趣可以继续关注
  • 小礼物走一走 or 点赞

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券