七、JAVA三大特性

最新推荐文章于 2024-04-22 09:19:04 发布

Hannaseyes

最新推荐文章于 2024-04-22 09:19:04 发布

阅读量704

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/Hannaseyes/article/details/51364586

版权

Java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

面向对象三大特性封装，继承和多态

封装

封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面(方法)。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术。

封装是分为两部分：属性的封装，方法的封装。封装起来就是为了对外隐藏。

类本身和方法本身就是一种封装，体现的是装配的含义。

在java中通过关键字private实现封装。什么是封装？封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。

属性的封装通过private，同时还要提供可以访问该私有属性的方法。

这个方法就要写在类里面。

Java里面对私有属性提供了两个方法：setter和getter，而且这两个方法必须是public。

package yantai;

import java.util.Scanner;

public class Account {

private double balance=100;

private String cardNo;

public double getBalance() {

///

Scanner s=new Scanner(System.in);

System.out.println("请输入密码");

String passwd = s.next();

if(!passwd.equals("ok")){

System.out.println("输入密码不正确....");

throw new RuntimeException();

}

return balance;

}

public void setBalance(double balance) {

this.balance = balance;

}

public String getCardNo() {

return cardNo;

}

public void setCardNo(String cardNo) {

this.cardNo = cardNo;

}

/**

* 存款

public void deposit(int money){

this.balance=this.balance+money;

System.out.println("存了："+money);

System.out.println("目前卡余额："+this.balance);

}

/**

* 取款

public void withdraw(int money){

this.balance=this.balance-money;

System.out.println("取了："+money);

System.out.println("目前卡余额："+this.balance);

}

public static void main(String[] args) {

//先创建一个对象，对象名字叫小明

Account a = new Account();

System.out.println(a.balance+"-----------");

a.deposit(100);

a.withdraw(200);

}

继承

使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，同时也拥有了父类的功能，使得复用以前的代码非常容易，减少重复代码的编写。能够大大缩短开发周期

父类：（超类）被继承

子类：（派生类）继承父类，并有自己新的特性。

什么时候适合设计成类之间的继承关系？

为了重复利用代码
这两个类之间有一种is a关系

子类对象构建过程：

定义子类对象时：

分配空间（父类对象空间，子类对象空间）

递归构造父类对象

初始化属性

调用构造方法：先调用父类的构造方法再调用子类的构造方法

子类可以把父类的什么修饰符修饰的属性和方法继承过来。Public,protected,default(父类和子类在同一个包)。

访问修饰符

一共是四种：public ,protected—为了继承,default,private

子类：派生类

父类：超类

方法的重载（Overload）

涉及到一个类，要求这些方法的方法名一样，但是参数不同。

方法都在同一个类里面。

方法的覆盖(Override)

前提是需要有继承关系，涉及到两个类，父类和子类。

方法重写：

子类重新定义父类的同名方法，主要是重写定义方法体。
父类是公有的修饰符，子类一定是公有的。父类如果是protected，子类可以是protected，或者public

子类比父类更开放。

3.子类重写的方法的返回值类型可以是跟父类一样，或者是父类返回值类型的子类。

super关键字（this关键字 ---当前对象）

可以通过super.属性名调用从父类继承过来的属性

通过super.方法名调用父类定义的方法

通过super()调用父类的构造方法。

定义子类对象，调用父类的构造方法的时候，一定子类构造方法的第一行，并且不一定就是调用空参数的父类的构造方法，只要是调用父类随便一个构造方法都可以，但是，只能调用一次。

public Dog(){

super(30);//首先调用父类的无参的构造方法

System.out.println();

}

Java继承的限制：

1.继承只能是单继承，只能有一个直接父类。只能有一个爹

2.可以多层继承，父类有父类爷爷

3.私有的属性和方法不能被继承私有就是为了自己类可用，子类当然不能用

课堂代码：

public class Animal {

public Animal(int age, char sex) {

this.age = age;

this.sex = sex;

}

public Animal(){

System.out.println("---------Animal Constructor-----------");

}

protected  int age=0;

private char sex;

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public char getSex() {

return sex;

}

public void setSex(char sex) {

this.sex = sex;

}

/**

* 吃饭

*/

public  void eat(){

System.out.println("I can eat");

}

/**

* 睡觉

*/

protected   void sleep(){

System.out.println("I can sleep 8 hours");

}

/**

* 发出叫声

*/

public  void call(){

System.out.println("call.......................");

}

public Animal getAnimalInstance(){

return new Animal();

}

}

package yantai;

public class Dog extends Animal{

int age=1;

@Override

public Dog getAnimalInstance() {

// TODO Auto-generated method stub

return null;

}

@Override

public  void sleep() {

// TODO Auto-generated method stub

System.out.println("8 hours");

}

public Dog(){

super(12,'f');

System.out.println("------Dog constructor---------");

}

/**

* 看门

*/

public void watchDoor(){

System.out.println("I can watchDoor");

}

public void print(){

System.out.println("the age is :"+super.age);

}

}

多态

多态需要具备什么前提？

类之间有继承关系
多个子类需要对父类的某个方法进行重写。

3.一个父类的引用指向一个子类的对象。

Animal a = new Dog();

Animal a = new Cat();

Animal a = new Pig();

多个子类共同继承父类，定义时候用父类变量分别指向不同子类对象

注意：

父类的引用指向子类的对象，但是父类的引用只能访问到父类定义的方法声明。
他访问父类当中被重写的方法，最终是访问子类的方法。

多态总结：一个变量能做什么要由类型决定，一个变量怎么做由对象决定。

深度分析: invokespecial选择方法基于引用的类型，而不是对象所属的类。但invokevirtual则选择当前引用的对象

课堂举例：动物发出叫声的多态----玩具

package com;

public class Animal {

private int age;//年龄

private char sex;//性别

private String skin;//肤色

private String type;//类型

public Animal(){

}

/**

* 睡觉

*/

protected void sleep(){

System.out.println("-------------sleep 8 hours---------------");

}

/**

* 吃饭

*/

public void eat(){

System.out.println("-------------eat something---------------");

}

/**

* 叫声

*/

public void call(){

System.out.println("-------------calling....---------------");

}

}

class Dog extends Animal{

public void call(){

System.out.println("-------------wangwang....---------------");

}

}

class Pig extends Animal{

public void call(){

System.out.println("-------------hengheng....---------------");

}

}

class Cat extends Animal{

public void call(){

System.out.println("-------------miaomiao....---------------");

}

}

Toy.java

package com;

public class Toy {

public static void main(String[] args) {

// TODO Auto-generated method stub

Toy toy=new Toy();

toy.pressButton(new Dog());

toy.pressButton(new Cat());

}

public static void pressButton(Animal a){

//根据信号来判断这是什么动物，然后发出声音

a.call();

}

}

台灯发光的问题。

一盏台灯，换上不同颜色的灯泡会发出不同颜色的光。