黑马程序员 JAVA面向对象基础

最新推荐文章于 2021-10-19 14:43:43 发布

liukai1213

最新推荐文章于 2021-10-19 14:43:43 发布

阅读量191

点赞数

本文链接：https://blog.csdn.net/liukai1213/article/details/48525871

版权

　------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

面向对象
封装的原则
　　　要求使对象之外的部分不能随意存取对象的内部数据，从而有效避免了错误对它的“交叉感染”，使软件错误能局部化，降低排错难度

继承

　　所有的类都继承自java.lang.Object，一些常用的方法：

　　　　equals():比较两个对象引用时否相同。

　　　　getClass():返回对象运行时所对应的类的表示，从而得到相应的信息

　　　　toString():返回对象字符串表示

　　　　finalize():用于在垃圾收集前清除对象

　　　　notify(), notifyall(), wait(): 用于多线程处理中的同步

　　子类（subclass）对父类（superclass，超类）的继承

　　子类不能继承父类中访问权限为private的成员变量和方法。

　　子类可以重写父类的方法，及命名与父类同名的成员变量。

　　Java不支持多重继承

　　创建子类

　　　　class SubClass extends SuperClass {

　　　　　　...

　　　　}

　　成员的隐藏和方法的重写

　　　　子类通过隐藏父类的成员变量和重写父类的方法，可以把父类的状态和行为变为自身的状态和行为。

多态性
　　子类继承父类后，同一个方法有不同的表现

　　体现在两个方面：方法重载实现的静态多态性（编译时多态），方法重写实现的动态多态性（运行时多态）

　重写方法的调用原则：子类重写父类的方法，调用子类方法；反之，调用父类的方法

　　一个对象可以引用子类的实例来调用子类的方法

　　eg: B继承A，A的对象a引用B的实例，调用B的方法callme()

 1 import java.io.*;
 2 class A {
 3     void callme() {
 4         System.out.println("Inside A's callme()) method");
 5     }
 6 }
 7 
 8 class B extends A {
 9     void callme() {
10         System.out.println("Inside B's callme() method");
11     }
12 }
13 
14 public class Dispatch {
15     public static void main(String args[]) {
16         A a = new B(); // 引用子类的实例
17         a.callme(); 
18     }
19 }

类的实现
　　类声明
　　　　[public][abstract|final] class className [extends superclassName] [implements interfaceNameList] {}
　　　　　　修饰符public, abstract, final说明类的属性
　　　　　　className为类的属性
　　　　　　superclassName为父类的名字
　　　　　　interfaceNameList为类所实现的接口列表

　　类体
　　　　class className
　　　　{
　　　　　　[public | protected | private] [static] [final] [transient] [volatile] type variableName; // 成员变量
　　　　　　[public | protected | private] [static] [final | abstract] [native] [synchronized] returnType methodName(
　　　　　　　　[paramList]) [throws exceptionList] {statements}; //成员方法
　　　　}

　　成员变量
　　　　[public | protected | private] [static] [final] [transient] [volatile] type variableName; // 成员变量
　　　　　　static: 静态变量（类变量）
　　　　　　final: 常量
　　　　　　transient：暂时性变量，用于对象存档
　　　　　　volatile：共享变量，用于并发线程的共享

　　成员方法
　　　　[public | protected | private] [static] [final | abstract] [native] [synchronized] returnType methodName(
　　　　[paramList]) [throws exceptionList] {statements}; //成员方法
　　　　　　static: 类方法，可通过类名直接调用
　　　　　　abstract: 抽象方法，没有方法体
　　　　　　final：方法不能被重写
　　　　　　native：集成其他语言的代码
　　　　　　synchronized：控制多个并发线程的访问

　　Java类中的限定词：

　　　　private：类中限定为private的成员，只能被这个类本身访问。如果构造方法为private，则其他类不能实例化该类。

　　　　default：不加任何访问权限，可以被这个类本身和同一个包中的类访问。

　　　　protected：类中限定为protected的成员，可以被这个类本身、它的子类和同一个包中的其他类访问。

　　　　public：类中被限定为public的成员，可以被所有类访问。

　　final关键字可以修饰类、类的成员变量和成员方法，但作用不同

　　　　修饰成员变量：称为常量，须给出初始值

　　　　修饰成员方法：该方法不能被子类重写

　　　　修饰类：类不能被继承

　　　　super: 访问父类的成员　

　　　　　　访问父类被隐藏的成员变量，如super.variable;

　　　　　　调用父类中被重写的方法，如super.Method([paramlist]);

　　　　　　调用父类的构造函数，如super([paramlist]);

eg:

 1 import java.io.*;
 2 class SuperClass {
 3     int x;
 4 
 5     SuperClass() {
 6         x = 3;
 7         System.out.println("in SuperClass: x = " + x);
 8     }
 9 
10     void doSomething() {
11         System.out.println("in SuperClass.doSomething()");
12     }
13 }
14 
15 class SubClass extends SuperClass {
16     int x;
17 
18     SubClass() {
19         super();
20         x = 5;
21         System.out.println("in SubClass: x = " + x);
22     }
23 
24     void doSomething() {
25         super.doSomething();
26         System.out.println("in SubClass.doSomething()");
27         System.out.println("Super.x = " + super.x + "sub.x = " + x);
28     }
29 }
30 
31 public class Inhereritance {
32 
33     public static void main(String chars[]) {
34         SubClass sc = new SubClass();
35         sc.doSomething();
36     }
37 }

　　简单数据：值类型
　　复合数据：引用类型

 1 import java.io.*;
 2 public class PassTest {
 3     float ptValue;
 4 
 5     public static void main(String args[]) {
 6         int val;
 7         PassTest pt = new PassTest();
 8         val = 11;
 9         System.out.println("Original int Value is:"+val);
10         pt.changeInt(val);
11         System.out.println("Int Value after Change is:"+val);
12         pt.ptValue = 101f;
13         System.out.println("Original ptValue is:"+pt.ptValue);
14         pt.changeObjectValue(pt); // 引用类型的参数
15         System.out.println("ptValue after change is:"+pt.ptValue);
16 
17     }
18 
19     public void changeInt(int value) {
20         value = 55;
21     }
22 
23     public void changeObjectValue(PassTest ref) {
24         ref.ptValue = 99f;
25     }
26 }

简单数据类型作为参数传递时，为值传递；复合数据类型作为参数传递时，为地址传递

　　方法体
　　　　方法的实现。方法体中局部变量若与成员变量同名，局部变量将屏蔽成员变量。

 1 import java.io.*;
 2 class Variable {
 3     int x = 0, y = 0, z = 0; // 类的成员变量
 4 
 5     void init(int x, int y) {
 6         this.x = x;
 7         this.y = y;
 8         int z = 5;  // 局部变量
 9         System.out.println("** in init**");
10         System.out.println("x = " + x + "y = " + y + "z = " + z);
11     }
12 }
13 
14 public class VariableTest {
15     public static void main(String args[]) {
16         Variable v = new Variable();
17         System.out.println("** before init **");
18         System.out.println("x = " + v.x + "y = " + v.y + "z = " + v.z);
19         v.init(20, 30);
20         System.out.println("** after init **");
21         System.out.println("x = " + v.x + "y = " + v.y + "z = " + v.z);
22     }
23 }

　　方法重载

　　　　指多个方法享有相同的名字。这些方法的参数必须不同。且参数类型区分度要足够：如不能使同一简单类型的数据：int与long

 1 import java.io.*;
 2 
 3 class MethodOverloading {
 4     void receive(int i) {
 5         System.out.println("Receive in data");
 6         System.out.println("i = " + i);
 7     }
 8 
 9     void receive(int x, int y) {
10         System.out.println("Receive two in datas");
11         System.out.println("x = " + x + "y = " + y);
12     }
13 }
14 
15 public class MethodOverloadingTest {
16     public static void main(String args[]) {
17         MethodOverloading mo = new MethodOverloading();
18         mo.receive(1);
19         mo.receive(2, 3);
20     }
21 }