标题图
构造函数实例
- 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 中的类只支持单继承, 不支持多继承.
类成员的继承:
对于继承: 一个类中有成员变量和方法.
子类继承父类, 可以有部分继承它的父类, 也可以自己定义.
子类能继承 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();
多态是同一种行为的不同表现形式或形态的能力.
多态步骤
有继承关系;
子类要重写父类的方法;
父类要指向子类的引用
案例
- // 抽象动物类
- 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 提供的包发生冲突的名字.
来源: http://www.jianshu.com/p/2122df9b95ad