自己总结面向对象编程的总结

最新推荐文章于 2022-04-29 00:23:51 发布

congdui9505

最新推荐文章于 2022-04-29 00:23:51 发布

阅读量105

点赞数

面向对象的思想：
它是超乎语言之上的概念，其它面向对象思想的语言都是一样的。
面向对象的三大特征：封装，继承，多态。
封装：对外部不可见，封装数据，可以起到保护作用，不会一不小会漏掉一些数据。
继承：用于扩展类的功能，在JAVA中只有单继承，如果要实现像C++那样多继承，在JAVA中就要用到接口，它可以避免了多继承中成员方法，成员变量的重复的特点。
多态：(最重要)

下面我对面向对象的其中一部分知识点做出概括：

对象的定义：
类名对象名 = new 类名();举例：Student stu = new Student();
我分析一下这里的机制。首先在栈内存有Student类型的name:stu， value:xx(这个值是与堆内存的联系----指针)。因为在堆内存存的就是一个个对象模块，所以new出来的Student这个实际对象就会在堆内存出现。此时就会执行Student的构造方法，然后返回对象实例的引用。俗点说，大家只要记住这点就好了：声明一个对象(栈内存中开辟了一个空间)，实例化一个对象(堆内存开辟了空间，此时对象的引用stu就拥有了Student使用权)。
栈：对象名，堆：对象属性，全局代码区：所有方法的代码，全局数据区：存放static类型的数据

垃圾收集器的机制：最简单的理解如下：
在程序中，不再有任何指向的空间---垃圾空间。JAVA中的垃圾是由JVM回收，自动完成

封装：让使用者只能通过实现定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作，也便于修改，增强代码的可维护性。就用private关键字实现封装。采用SetXxx()和GetSxx()来访问封装类内部的成员方法和成员变量。private起到了让外部看不到。就起到了封装，不会随便漏掉数据了。

JAVA权限修饰符： public protected private
private：只能访问类内部的成员方法和成员变量
default：除了拥有private功能之外，其他对象还可以访问同一个包中类的成员方法和成员变量。当我们定于成员方法或成员变量时，不写任何修饰符的时候，就默认用default。一般不写default。也就是说default类只能被同一个包中的类访问
protected：除了拥有default能访问同一个包中的方法和属性之外，还可以访问子类的方法和属性。
public ：这个不用说了，任何地方都可以访问本类的方法和属性。
定义class的权限修饰只能用public 和default。

匿名对象：比如new Student().sing();它的意思是调用Student类的sing()方法。
特点：可以不定义对象引用的名称，而直接调用这个对象的方法。
使用：如果对一个对象只需要进行一次方法的调用，那么就可以使用匿名对象。
常用：经常将匿名对象作为实参传递给一个方法调用。

String类的使用：
①特点：String类中的内容一旦声明则不可改变
解释：不可以尝试通过方法改变已经声明字符串的内容。这点可以从内存角度来解释。
②两种使用方法：第一：private String name1 = "刘少科"; 第二：private String name2 = new String("刘少科");如果大家这样输出：System.out.print(name1==name2);System.out.print(name1.equals(name2));输出内容前者是false后者是true。
equals：是两个内容的比较，字符串的内容或者对象里面的内容
"=="：数值比较，比较的是内存地址的值是否相等。这点大家可以参考有关文档，我不详细介绍了。
总结：直接赋值----只开辟了一个空间，使用new：开辟了两个空间(其中有一个是垃圾空间)
③ String使用了JAVA中的共享设计模式：举例：private String name1="刘少科"; private name2 = "刘少科"; System.out.private(name1==name2);是TRUE还是FALSE？String类非常特别。解释：当你定义name2时，如果已经定义了内容一样了name1，则name2不会再生成另外一块空间，此时，name1和name2都会指向"刘少科"，所以它们的地址是一样的，怎上面的返回值肯定是true。
④补充：举例：String str="liushaoke"; for(int i=0;i<100;i

构造方法：
①特点：它具有与类名相同的名称，它不含返回值类型的定义，也没有返回值
②调用机制：构造方法在实例化对象时被自动调用，主要用来为类中的属性作初始化工作
③形式：如果没有写构造方法，则每当实例化对象时，自动生成一个无参的什么都不做的构造方法，如果明确写了无参构造方法，则不会再自动生成无参的构造方法。构造方法的重载我会在后面在总结。建议：无论采用哪种方法为类中的属性赋值，最好都经过Setter方法，由Setter方法对输入的内容进行检测，而Getter方法只是将内容简单地返回。

方法重写(overwrite/override)：有几个基本原则
①在子类中可以根据需要对从父类中继承来的方法进行重写。
②重写方法必须和被重写方法具有相同的方法名称，参数列表和返回类型。
③重写方法不能使用被重写方法更严格的访问权限
注意：第二点很容易犯错误，一定要copy原来的方法，如果自己写的话，极容易出错，这种错误很难找，要有这种重写的意识。

方法重载(overload)：
特点：方法名相同。但是参数的类型或个数不同l。

this的使用：
①在类的方法定义中使用的this关键字代表使用该方法的对象的引用。
②当必须指出当前使用方法的对象时是谁？这时候就要用到this。
③有时候用this可以处理方法中成员变量和参数重名的情况，比如
private String name;
public void run(String name){
this.name = name;
}
④this可以看成一个变量，它的值是当前对象的引用。
对第四点解释：它不是任何对象的引用，this是指向自己本身的类的引用，它是堆内存的，与栈内存没有任何一点关系。因为它是指向自己本身。俗点说this就是当前的类，只不过是一个引用。
⑤this调用本类属性，本类方法，构造方法这三点，是this的基本运用，也是最常用的，综合起来就是一点------表示当前对象。举例：
class Student{
private String name;private String age;
public Student(){}
public Student(String name){ this.name=name}
public Student(String name,String age){this(name);this.age=age}
}
我在这里举这个例子就可以说明前面的一些理论。注意，构造方法重载中的this(name);这个一定要放在Student含两个参数构造方法的首行。

super的使用：和this很相似
①调用父类的方法：调用父类的特定构造方法。如 super();super(name);super(name,age);
我举个例子：
class a extends Student{
public void printStuInfor(){
   super();
   super("刘少科")；
   super("刘少科"，22)；
}
}
也就是说可以通过super(),里面根据传入的参数区调用父类中指定的构造方法，默认是调用无参构造方法
②调用父类中被覆盖的方法：通过调用super().父类的方法就可以在实例化子类时调用父类的方法------------相当方法被重写了，所以这时在子类就可以增加自己新的方法就可以了，默认就会执行super()方法。

this与super() 的区别：
两者用法很相似。
this与super调用构造的操作能同时在一个构造方法出现吗？肯定不行，只能用一个。

static的用法：
①static属性可以被static和非static类型的方法所使用，非static属性不可以被static方法使用。
②static声明的属性，表示此属性为公有属性，也就是说：所有对象都可以访问此属性。它是存放在全局数据区。可以用类名加点来直接访问static属性。如果你想尝试通过某个具体的对象改变static属性的内容，对不起，你改不了。
③静态方法不能调用非静态属性和方法，非静态方法可以调用静态属性和方法。
④static代码块：
首先解释一下JAVA的四种代码块的区别：
一，普通代码块：是写在一个方法之中的语句块
二，构造块：是直接写在类中的一个语句块，构造块优先于构造方法执行
三，静态块：是直接写在类中的，通过static声明的语句块，优先于构造块和构造方法，主要作用是为静态属性初始化，只执行一次。
四，同步代码块：经典的用处是在多线程的线程同步。

继承的使用：
   特点：实现功能的扩展，良好的扩展性有利于以后功能的扩展。
   规定：JAVA只支持单继承，没有多继承，就像一个小孩只有一个血缘关系的父亲。
   注意：子类可以继承父类中的公有属性和共有方法，而不能直接操纵父类中的私有方法。
        可以通过封装的特性来访问父类的私有属性和私有方法。
   补充：要先有父类才能有子类的产生，所以当你实例化子类时，它会先执行父类的构造方法，先产生父类，之后才会执行子类的有关方法。它会调用super();如果在子类没有写super();在实例化时会自动掉用默认的super();

final关键字的使用：-----相当于太监。呵呵呵
①final标记的泪不能被继承
②标记的方法不能被子类重写
③final标记的变量（成员变量或局部变量）即成为常量，只能赋值一次。
全局常量的定义：public static final。数据存在全局数据区。final定义的变量一般用大写。

抽象类：
①定义：类和方法必须用abstract修饰
②原则：抽象类不能被直接实例化，抽象方法只能声明，而不需要实现。
③含有抽象方法的类必须被声明为抽象类，抽象类的子类必须重写父类的抽象方法。
注意：抽象类必须有子类，子类如果不是抽象类的话，则必须重写抽象类的全部方法
我问大家：抽象类可以有构造方法吗？还有抽象类可以用final声明吗？
解释：构造方法是对象实例化时使用的。子类对象在实例化对象时依照先实例化父类中的属性，再实例化本类中的属性，这和在一般的继承中，实例化对象时的机制一样的。final可以声明一个类，但是此类是不能有子类的父类，但是抽象类必须要有子类的实现，所以抽象类一定不可以用final声明。

接口：是抽象方法和常量的集合。
抽象类中包含抽象方法，那如果全部都是抽象方法，则可以用接口来表示。
常量定义：一定要这样用：public static final String name;如果你没有这么写，而写成了String name;则会默认像前面那样。举例：
interface Person{
public static final String furColor="orange";
public void Sing();
public void say();
}
class student implements Person{
//在这里一定要重写接口中的方法
}
一个类可以同时实现多个接口。
一个接口可以允许继承多个接口
但是一个类是不允许继承多个类的

多态的知识点：
●接口和抽象类很重要，多态就是最好的体现。
•方法的多态性(重载)：同一个方法名称根据传入参数的不同，完成的功能也不同
•对象的多态性：它是在继承应用上的一种扩展，所以多态是建立在继承关系之上。
*面向对象程序开发的一个思路：【建议】永远不要去继承一个普通类
子类对象和父类对象之间的转换
★向上转型：子类对象向父类对象转换(⊕自动转型父类对象=子类对象 )
★向下转型：父类对象向子类对象转换(☉强制转换子类对象=(子类)父类对象 )
注意点：如果一个方法被子类重写了，则子类与父类发生转换，自动去调用已经被重写过的方法(子类中的方法);★★★★★
对象多态性最核心的部分：方法的覆写与继承的关系，只要有继承关系，只要有覆写过的方法，则子类向父类进行转型时，肯定调用被子类覆写过的方法(核心)
★接口与抽象类的实际应用：基础类，封装，继承，覆写，多态性。

对象多态性
开发建议：不要去继承一个已经实现好的类
如果以后在开发中需要继承，则大部分情况下继承的都会是一个抽象类，当然，也有一个问题，抽象类有JAVA单继承局限，不能多继承。所以用到接口。

接口的实际应用：
接口的使用：将方法名暴露给用户(比较难理解)
接口对象的实力：通过对象的多态性，由子类为接口对象实例化

抽象类与接口在使用上非常的相似。
在开发过程上讲：优先使用接口，接口允许多继承的特点。
抽象类与接口的比较：
相同点：对象不能直接实例化，通过多态性，可有其子类实例化
不同点：
抽象类：包括一般方法，抽象方法，变量，常量；可以有构造方法；抽象类可以实现多个接口；继承时，单继承会有局限。
接口：包括常量，抽象方法；不能有构造方法；接口不能继承一个抽象类；解决单继承的局限。
注意这样一个特点：接口中都是抽象方法，则子类必须全部覆写接口中的全部抽象方法，那么如果现在子类不希望全部都覆写呢？又怎样操作？用适配器Adapter：适配器的设计模式
接口---抽象类---子类

接口可以进一步扩展---------工厂设计模式
接口与抽象类的应用：(需要长时间的训练才能读透，我也不是很熟练哦，呵呵，大家一起进步哦)

附录：一个是多态性在抽象类的应用，一个是用抽象类实现继承，一个是用接口实现继承
abstract class Person
{
private String name ;
private int age ;
public Person(String name,int age)
{
  this.setName(name) ;
  this.setAge(age) ;
}
public void setName(String name)
{
  this.name = name ;
}
public void setAge(int age)
{
  this.age = age ;
}
public String getName()
{
  return this.name ;
}
public int getAge()
{
  return this.age ;
}
// 将说话的内容作为一个抽象方法，通过子类去实现
public void say()
{
  System.out.println(this.getContent()) ;
}
public abstract String getContent() ;
};
// 假设人分为两种：一种是工人，一种是学生
// 工人有工资，学生有成绩
// 不管是学生还是工人，肯定都可以说话
// 说话的内容不一样
class Worker extends Person
{
private float salary ;
public Worker(String name,int age,float salary)
{
  super(name,age) ;
  this.setSalary(salary) ;
}
public void setSalary(float salary)
{
  this.salary = salary ;
}
public float getSalary()
{
  return this.salary ;
}
public String getContent()
{
  return "工人说 --&gt 姓名："+super.getName()+"，年龄："+super.getAge()+"，工资："+this.getSalary() ;
}
};
class Student extends Person
{
private float score ;
public Student(String name,int age,float score)
{
  super(name,age) ;
  this.setScore(score) ;
}
public void setScore(float score)
{
  this.score = score ;
}
public float getScore()
{
  return this.score ;
}
public String getContent()
{
  return "学生说 --&gt 姓名："+super.getName()+"，年龄："+super.getAge()+"，成绩："+this.getScore() ;
}
};
public class OODemo03
{
public static void main(String args[])
{
  Person p = null ;
  // p = new Student("张三",30,90) ;
  p = new Worker("张三",30,3000) ;
  p.say() ;
}
};

interface USB
{
// 开始工作
public void start() ;
// 停止工作
public void stop() ;
}
// 对于PC机上认的是一个USB接口
class PC
{
public static void plugin(USB u)
{
  u.start() ;
  u.stop() ;
}
};
class Mp3 implements USB
{
public void start()
{
  System.out.println("Mp3开始工作了。。。") ;
}
public void stop()
{
  System.out.println("Mp3停止工作了。。。") ;
}
};

class UDisk implements USB
{
public void start()
{
System.out.println("U盘开始工作了。。。") ;
}
public void stop()
{
System.out.println("U盘停止工作了。。。") ;
}
};

public class OODemo05
{
public static void main(String args[])
{
PC.plugin(new UDisk()) ;
}
};

interface A
{
public void fun1() ;
public void fun2() ;
public void fun3() ;
}
abstract class B implements A
{
public void fun1()
{}
public void fun2()
{}
public void fun3()
{}
};
class C extends B
{
public void fun1()
{
  System.out.println("HELLO 垃圾广告 ...") ;
}
};
public class OODemo06
{
public static void main(String args[])
{
  A a = new C() ;
  a.fun2() ;
}
};

interface USB
{
// 开始工作
public void start() ;
// 停止工作
public void stop() ;
}
class Mp3 implements USB
{
public void start()
{
System.out.println("Mp3开始工作了。。。") ;
}
public void stop()
{
System.out.println("Mp3停止工作了。。。") ;
}
};

class UDisk implements USB
{
public void start()
{
  System.out.println("U盘开始工作了。。。") ;
}
public void stop()
{
  System.out.println("U盘停止工作了。。。") ;
}
};
// 假设现在要修改子类，则要修改mian方法，是一个程序的客户端
class Factory
{
public static USB getUSBInstance()
{
  return new UDisk() ;
}
};
public class OODemo07
{
public static void main(String args[])
{
  USB u = Factory.getUSBInstance() ;
  u.start() ;
  u.stop() ;
}
};

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/21359667/viewspace-588691/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/21359667/viewspace-588691/

congdui9505

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
自己总结面向对象编程的总结

面向对象的思想：它是超乎语言之上的概念，其它面向对象思想的语言都是一样的。面向对象的三大特征：封装，继承，多态。封装：对外部不可见，封装数据，可以起到保护作用，不会一不小会漏掉一些数据。继承：用于扩展类的功能，在JAVA...
复制链接

扫一扫