Java SE 03 面向对象

1.    对象和类的概念

2.    类之间的关系

关联关系-实线

继承关系-实线空心箭头

聚合关系-实线菱形

实现关系-虚线空心箭头

多态:多种不同实现方式

UML类图几种关系的总结

https://www.cnblogs.com/liuxiaoji/p/4704294.html

3.    Java类的定义

4.    对象和引用

5.    对象的创建和使用

非静态方法是针对具体对象进行调用

6.    构造函数

 

命名规则：

类名的首字母大写；

变量名和方法名的首字母小写；

运用驼峰标识。

 

内存解析：

class BirthDate {
    private int day;
    private int month;
    private int year;
   
    public BirthDate(int d, int m, int y) {
        day = d;
        month = m;
        year = y;
    }
   
    public void setDay(int d) {
           day = d;
      }
     
    public void setMonth(int m) {
           month = m;
    }
   
    public void setYear(int y) {
           year = y;
    }
   
    public int getDay() {
           return day;
    }
   
    public int getMonth() {
           return month;
    }
   
    public int getYear() {
           return year;
    }
   
    public void display() {
           System.out.println
        (day + " - " + month + " - " + year);
    }
}
 
 
public class Test{
    public static void main(String args[]){
        Test test = new Test();
        int date = 9;
        BirthDate d1= new BirthDate(7,7,1970);
        BirthDate d2= new BirthDate(1,1,2000);   
        test.change1(date);
        test.change2(d1);
        test.change3(d2);
        System.out.println("date=" + date);
        d1.display();
        d2.display();
    }
   
    public void change1(int i){
           i = 1234;
    }
   
    public void change2(BirthDate b) {
           b = new BirthDate(22,2,2004);
    }
   
    public void change3(BirthDate b) {
           b.setDay(22);
    }
}

   Test为引用数据类型，栈内存中存储的引用指向堆内存中的对象，date为局部变量存在栈内存中，d1、d2同test但进行了初始化。↓

  

调用change1方法实参date的值9传递给形参i（局部变量，因此分配在栈空间上）。↓

i的值被改为1234。↓

Change1结束，局部变量i内存回收。↓

调用change2方法实参d1中的引用传递给形参b，d1和b指向同一对象（别名现象）。↓

b指向新的对象↓

形参b被回收，b原先指向的对象由于没有引用指向因而被java垃圾回收机制回收。↓

调用change3方法实参d2中的引用传递给形参b，d2和b指向同一对象（别名现象）。↓

Change3方法通过调用d2对象的setDay对象改变所指对象的值。

形参b被回收。

7.    方法的重载

8.    this关键字

9.    static关键字

public class Cat {
    private static int sid = 0;
    private String name;
    int id;
    Cat(String name) {
        this.name = name; 
        id = sid++;
    }
    public void info(){
        System.out.println
               ("My name is "+name+" No."+id);
    }
    public static void main(String arg[]){
 
        Cat.sid = 100;
        Cat mimi = new Cat("mimi");
        mimi.sid = 2000;
        Cat pipi = new Cat("pipi");
        mimi.info();
        pipi.info();
    }
}

10.  package和import语句

 

C:\Program Files\Java\jdk\jre\lib\rt.jar

11.  类的继承

class Person {
    private String name;
    private int age;
    public void setName(String name) {
           this.name=name;
    }
    public void setAge(int age) {
           this.age=age;
    }
    public String getName(){
           return name;
    }
    public int getAge(){
           return age;
    }
}
 
class Student extends Person {
    private String school;
    public String getSchool() {
           return school;
    }
    public void setSchool(String school) {
           this.school =school;
    }
}
 
public class Test {
    public static void main(String arg[]){
        Student student = new Student();
        student.setName("John");
        student.setAge(18);
        student.setSchool("SCH");
        System.out.println(student.getName());
        System.out.println(student.getAge());
        System.out.println(student.getSchool());
    }
}

Student student = new Student();内存分析。

12.  访问控制

 

13.  方法的重写

super关键字

在java类中使用super来引用基类的成分；

class FatherClass {
    public int value;
    public void f(){
        value = 100;
        System.out.println
        ("FatherClass.value="+value);
    }
}
 
class ChildClass extends FatherClass {
    public int value;
    public void f() {
        super.f();
        value = 200;
        System.out.println
             ("ChildClass.value="+value);
        System.out.println(value);
        System.out.println(super.value);
    }
}
 
public class TestInherit {
       public static void main(String[] args) {
              ChildClass cc = new ChildClass();
              cc.f();
       }
}

继承中的构造方法

14.  final关键字

15.  Object类

==对于引用类型比较的是引用

16.  对象转型

17.  多态

调用父类中被重写的方法时，运行中new的是哪个对象就调用哪个对象。

18.  抽象类

19.  接口

每个接口暴露了对象的一部分方法

public interface Valuable {
       public double getMoney();
}
 
interface Protectable {
       public void beProtected();
}
 
interface A extends Protectable {
       void m();
       void getMoney();
}
 
abstract class Animal {
       private String name;
      
       abstract void enjoy();
}
 
class GoldenMonkey extends Animal implements Valuable, Protectable {
       public double getMoney() {
              return 10000;
       }
      
       public void beProtected() {
              System.out.println("live in the room");
       }
      
       public void enjoy() {
             
       }
      
       public void test() {
              Valuable v = new GoldenMonkey();
              v.getMoney();
              Protectable p = (Protectable)v;
              p.beProtected();
       }
}
 
class Hen implements A  {
       public void m() {}
       public void beProtected() {}
/*    public double getMoney() {
              return 1.0;
       }
*/   
       public void getMoney() {}
 
}

20.  总结

<内存分析贯穿始终>

对象和类的概念（类、对象）

类（对象）之间的关系（关联、继承、聚集组合、多态、实现）

面向对象设计思想

（a.确定有哪些类和对象

b.类和对象的属性和方法

c.类和对象间的关系）

class

new

    引用的概念

    构造方法的概念

方法重载(参数列表不同)

    构造方法重载

this （当前对象）

static（堆内存，属于类而不是特定对象）

package&import

private default（包访问权限） protected（继承访问权限）public

extends（ **is a **）

overwite

final（不能被修改）

Object

    toString

    equals

upcasting （父类引用指向子类对象）downcasting

polymophysm/dynamic binding /late（继承、重写、父类引用指向子类对象）

abstract class（含有抽象方法）

interface

    implements

3.1类与对象

1.什么是类和对象？二者的关系？
1. 如何定义一个类？如何创建一个对象？
1.  什么是对象，如何创建对像？

1）对象：对象是人们要进行研究的任何事物，它不仅能表示具体的事物，还能表示抽象的规则、计划或事件。对象具有状态，一个对象用数据值来描述它的状态。对象还有操作，用于改变对象的状态，对象及其操作就是对象的行为。对象实现了数据和操作的结合，使数据和操作封装于对象的统一体中。

2）类：具有相同特性（数据元素）和行为（功能）的对象的抽象就是类。因此，对象的抽象是类，类的具体化就是对象，也可以说类的实例是对象，类实际上就是一种数据类型。类具有属性，它是对象的状态的抽象，用数据结构来描述类的属性。类具有操作，它是对象的行为的抽象，用操作名和实现该操作的方法来描述。

 

对象和类的关系：

类与对象的关系就如模具和铸件的关系，类的实力化的结果就是对象，而对对象的抽象就是类，类描述了一组有相同特性（属性）和相同行为的对象。

 

2.创建对象时，内存中的变化？

1：先将硬盘上指定位置的Person.class文件加载进内存。

2：执行main方法时，在栈内存中开辟了main方法的空间(压栈-进栈)，然后在main方法的栈区分配了一个变量p。

3：在堆内存中开辟一个实体空间，分配了一个内存首地址值。new

4：在该实体空间中进行属性的空间分配，并进行了默认初始化。

5：对空间中的属性进行显示初始化。

6：进行实体的构造代码块初始化。

7：调用该实体对应的构造函数，进行构造函数初始化。（）

8：将首地址赋值给p ，p变量就引用了该实体。(指向了该对象)

3.2 方法

1.如何定义方法？
2.什么是方法的参数和返回值？

方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

 修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。

 返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType是关键字void。

 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。

 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

 方法体：方法体包含具体的语句，定义该方法的功能。

20151023142602139.jpg (381×198)

如：

public static int age(int birthday){...}

参数可以有多个：

static float interest(float principal, intyear){...}

1.   什么是值传递？
2.  什么是引用传递？

1.值传递：(形式参数类型是基本数据类型)：方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。

2.引用传递：(形式参数类型是引用数据类型参数)：也称为传地址。方法调用时，实际参数是对象(或数组)，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法执行中形式参数的改变将会影响实际参数。

 

1.   什么是构造方法？

构造方法是一种特殊的方法，具有以下特点。

（1）构造方法的方法名必须与类名相同。

（2）构造方法没有返回类型，也不能定义为void，在方法名前面不声明方法类型。

（3）构造方法的主要作用是完成对象的初始化工作，它能够把定义对象时的参数传给对象的域。

（4）一个类可以定义多个构造方法，如果在定义类时没有定义构造方法，则编译系统会自动插入一个无参数的默认构造器，这个构造器不执行任何代码。

（5）构造方法可以重载，以参数的个数，类型，顺序。

2.   this关键字的含义及使用？

表示当前对象

一、this关键字主要有三个应用：

(1)this调用本类中的属性，也就是类中的成员变量；

(2)this调用本类中的其他方法；

(3)this调用本类中的其他构造方法，调用时要放在构造方法的首行。

3.   如何使用构造方法初始化对象？初始化的几个过程？

4.   默认构造方法和自定义构造方法的区别和联系？

如果一个类，你没有定义构造函数，那么系统默认会有一个无参的构造函数

但如果你定义了一个有参的构造函数，为了保证正确性，系统不会创建无参构造函数，这时候，如果你还想允许无参构造，就必须显式的声明一个

1.   什么是方法重载？

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。

2.方法重载的原则是什么？

一.方法名一定要相同。

二.方法的参数表必须不同，包括参数的类型或个数，以此区分不同的方法体。

1.如果参数个数不同，就不管它的参数类型了！

2.如果参数个数相同，那么参数的类型必须不同。

三.方法的返回类型、修饰符可以相同，也可不同。

 

3.3封装和访问控制

1.什么是包？

在Java中，我们写程序时用到相同的类名是有可能的，遇到这种情况的话，就会出现错误。

为了避免上述错误，Sun公司在开发Java时提出了包的的概念，就是package。包可以使具有相同类名的程序互不影响，从而保证了程序的正确性。

2.  使用package时需要注意什么？
3.怎样导入包？

java中导入jar包：首先对着myeclipse空白处，右键->Build Path->Configure Build Path...

点击Libraries->Add External JARs...，选择一个外部的jar包，打开，OK。

jar包导入工程后，就可以通过代码顶部，使用import导入包里的类，比如：import java.lang.System。

 

1.   什么是封装？

封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。

        1、良好的封装能够减少耦合。

        2、类内部的结构可以自由修改。

        3、可以对成员进行更精确的控制。

        4、隐藏信息，实现细节。

2.   java有哪些访问控制符？他们的访问级别分别是什么？
3.访问控制符如何使用？

 

3.4静态成员

1.什么是静态成员？使用什么关键字修饰？

被static关键字修饰的变量叫静态变量，也就是所谓的类变量。

不被static关键字修饰的变量叫成员变量

3.5对象数组

1.什么是对象数组？

对象数组就是数组里的每个元素都是类的对象，赋值时先定义对象，然后将对象直接赋给数组就行了。

3.  如何创建对象数组？怎样实例化对象数组？

实例化类

需要对数组中每一个元素进行实例化；

比如:

Person[] ps=new Person[10];
ps[0]=new Person(name0,phone0,...)
ps[1]=new Person(name1,phone1,...)
ps[2]=new Person(name2,phone2,...)
.....