构造函数实例

class Cat{ // 设置私有的属性 nameprivate 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中的类只支持单继承，不支持多继承。

类成员的继承：

对于继承：一个类中有成员变量和方法。

子类继承父类，可以有部分继承它的父类，也可以自己定义。

子类能继承public和protected的成员变量，不能继承private的成员变量，可以继承同包中的默认修饰符。

同理，子类继承父类的方法，能够继承public和protedted的方法，不能继承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.appletjava.awtjava.netjava.utiljava.langjava.io

包的格式：

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

引入java包

import  包层次结构的类名;

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

结语

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