疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

浅谈Java面向对象基础


 

  

  目录:1、面向对象三大特性 2、类和对象 3、内部类

  1、面向对象三大特性 封装、继承、多态

  封装

  概念:是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。

  好处:将变化隔离;便于使用;提高重用性;安全性。

  封装原则:将不需要对外提供的内容都隐藏起来,把属性都隐藏,提供公共方法对其访问。

  继承

  好处:子类将得到基类中的所有域和方法,提高了代码的复用性;让类与类之间产生了关系,提供了另一个特征多态的前提。

  多态

  简单例子:父类引用或者接口的引用指向了自己的子类对象。//Animal a = new Cat();

  多态的好处:提高了程序的扩展性。

  多态的弊端:当父类引用指向子类对象时,虽然提高了扩展性,但是只能访问父类中具备的方法,不可以访问子类中特有的方法。(前期不能使用后期产生的功能,即访问的局限性)

  多态的前提: 1:必须要有关系,比如继承、或者实现。 2:通常会有覆盖操作。

  关于基于继承的多态的一个代码示例

  复制代码

  1 /*

  2 对象的多态性:动物 x = new 猫();

  3 函数的多态性:函数重载、重写

  4

  5 1、多态的体现

  6 父类的引用指向了自己的子类对象

  7 父类的引用也可以接收自己的对象

  8 2、多态的前提

  9 必须是类与类之间只有关系,要么继承或实现

  10 通常还有一个前提,存在覆盖

  11 3、多态的好处

  12 多态的出现大大的提高了程序的扩展性

  13 4、多态的弊端

  14 只能使用父类的引用访问父类的成员

  15 5、多态的应用

  16

  17 6、注意事项

  18 */

  19

  20 /*

  21 需求:

  22 猫,狗。

  23 */

  24

  25 abstract class Animal

  26 {

  27 abstract void eat();

  28 }

  29

  30 class Cat extends Animal

  31 {

  32 public void eat()

  33 {

  34 System.out.println("吃鱼");

  35 }

  36 public void catchMouse()

  37 {

  38 System.out.println("抓老鼠");

  39 }

  40 }

  41

  42 class Dog extends Animal

  43 {

  44 public void eat()

  45 {

  46 System.out.println("吃骨头");

  47 }

  48 public void kanJia()

  49 {

  50 System.out.println("看家");

  51 }

  52 }

  53

  54 class DuoTaiDemo

  55 {

  56 public static void main(String[] args)

  57 {

  58 function(new Cat());

  59 function(new Dog());

  60

  61 Animal a = new Cat();//向上转型

  62 a.eat();

  63

  64 Cat c = (Cat)a;//向下转型

  65 c.catchMouse();

  66

  67

  68 }

  69

  70 public static void function(Animal a)

  71 {

  72 a.eat();

  73 //用于子类型有限

  74 //或判断所属类型进而使用其特有方法

  75 if(a instanceof Cat)

  76 {

  77 Cat c = (Cat)a;

  78 c.catchMouse();

  79 }

  80 else if(a instanceof Dog)

  81 {

  82 Dog c = (Dog)a;

  83 c.kanJia();

  84 }

  85 }

  86

  87

  88 }

  复制代码

  2、类和对象

  类 :一个类可以被定义为描述行为的模板/蓝色印花/指出其类型支持的对象。

  对象 :对象具有状态和行为。例如:狗有状态 - 颜色,名称,繁殖以及行为,摇头晃脑,吠叫,吃。对象是类的实例。

  从类创建对象时有三个步骤:

  1、声明: 变量声明,一个变量名的对象类型。

  2、实例: “new”关键字是用来创建对象。

  3、初始化: 关键字 new 后跟调用一个构造函数。这个调用初始化新的对象。

  关于构建类的一个简单例子:

  复制代码

  1 public class Employee{

  2 String name;

  3 int age;

  4 String designation;

  5 double salary;

  6

  7 // This is the constructor of the class Employee

  8 public Employee(String name){

  9 this.name = name;

  10 }

  11 // Assign the age of the Employee to the variable age.

  12 public void empAge(int empAge){

  13 age = empAge;

  14 }

  15 /* Assign the designation to the variable designation.*/

  16 public void empDesignation(String empDesig){

  17 designation = empDesig;

  18 }

  19 /* Assign the salary to the variable salary.*/

  20 public void empSalary(double empSalary){

  21 salary = empSalary;

  22 }

  23 /* Print the Employee details */

  24 public void printEmployee(){

  25 System.out.println("Name:"+ name );

  26 System.out.println("Age:" + age );

  27 System.out.println("Designation:" + designation );

  28 System.out.println("Salary:" + salary);

  29 }

  30 }

  复制代码

  3、内部类

  定义:将一个类的定义放在另一个类的定义内部。

  规则:内部类的创建和普通类没区别;

  内部类可以直接访问所属外部类中的成员(包括私有的)

  访问格式:外部类名.this.成员名,成员名不冲突是可直接用成员名调用,所属的外部类要访问内部类必须要建立内部类对象。

  局部内部类:1、不可以被成员修饰符修饰 2、可以直接访问外部类的成员,因为还只持有外部类的引用,在所在的局部中只能访问它所在的局部中的用final修饰的变量。

  匿名内部类(其实就是内部类的一种简写格式):定义匿名内部类的前提----内部类必须是继承一个类或者实现接口;

  格式:new 父类名字(){子类实现的内容};

  几种内部类的代码演示:

  复制代码

  1 public static void main(String[] args) {

  2 //创建非静态内部类的对象

  3 Test.TestInner tt=new Test().new TestInner();

  4 tt.show1();

  5 tt.show();

  6 tt.show2();

  7 //创建静态内部类的对象

  8 Test.Test1Inner tt1=new Test.Test1Inner();

  9 tt1.show();

  10 //直接调用静态内部类中的静态方法

  11 Test.Test1Inner.show1();

  12

  13 Test tn=new Test();

  14 tn.show();//验证局部内部类

  15 tn.show1();//验证匿名内部类

  16 }

  17

  18 }

  19 class Test{

  20 int a=1;

  21 public void show(){

  22 final int a=90;

  23 System.out.println("Test show a:"+a);

  24 new TestInner().show();//外部类非静态方法访问非静态内部类中的方法

  25 //局部内部类,调用方法中的局部变量要被final修饰

  26 class MethodClass{

  27 public void show1(){

  28 System.out.println("Test show1 MethodClass show1 a:"+a);

  29 }

  30 }

  31 new MethodClass().show1();

  32 }

  33 public void show1(){

  34 //匿名内部类,直接在对象后使用其重写的方法,调用方法中的局部变量要被final修饰

  35 final int a=80;

  36 new Test2(){

  37 @Override

  38 public void show() {

  39 System.out.println("大家好,这里是Test类中的show1方法中继承了Test2抽象类的匿名内部类..."+a);

  40 }

  41

  42 }.show();

  43 }

  44 //普通内部类

  45 class TestInner{

  46 int a=2;

  47 public void show(){

  48 System.out.println("TestInner show a:"+a);

  49 }

  50 public void show1(){

  51 System.out.println("Test TestInner show1----:");

  52 Test.this.show();//非静态内部类访问所属外部类的非静态方法

  53 }

  54 public void show2(){

  55 System.out.println("Test TestInner show2----:");

  56 new Test.Test1Inner().show();//非静态内部类访问所属外部类的静态类的方法

  57 }

  58 }

  59 //静态内部类

  60 static class Test1Inner{

  61 static int a=9;

  62 public void show(){

  63 new Test().new TestInner().show();//静态内部类调用非静态内部类中的方法

  64 }

  65 public static void show1(){

  66 System.out.println("Test Test1Inner show1 a:"+a);

  67 }

  68 }

  69 }

  70 abstract class Test2{

  71 public abstract void show();

  72 }

  复制代码