面向对象简单总结

面向对象总结

1.初识对象

   1.1（熟悉面向对象

          表格法

          引入对象及类）

想要更具体的了解面对对象，明白什么是变量，我们在学习中引入一个表格的方法，来映射给对象，数据就是由一个个表格组成的，表格的表头就好像一个类，。一个模板，通过这个模板，给i与信息的赋值，就得到了我们的对象，在Java中一切都是对象。

   1.2面对过程＆面对对象

          （进化史

          区别

          面向对象设计和分析思维

          写诗例子）

在java之前有c语言，而c语言就是典型的面对过程，将一个程序的运行拆分成一个个小程序，一个个的去完成，对于java，这是一个面对对象的语言，是一个设计程序的软件，并不真正的实现它的现实功能。面向过程适合简单、不需要协作的事务，重点关注如何执行。面对对象更加注重设计者思维。好比一首诗，就是一个面对对象的过程，要想写好诗，就要很好的把景物融入诗中。

   1.3类和对象

          （定义

          属性

          方法）

类可以看成一类对象的模板，对象可以看成该类的一个具体实例，类是一个比较啊抽象的东西，比如我们说学生，那现实中的学生有哪些特征，这些特征就是一个类应该有的属性，也就是成员变量而方法就是类的行为特征。那我们定义一个学生类就要有类的声明，属性的初始化，以及方法的调用。

   1.4构造方法

          （定义方法

          四大要点

                 没有定义构造器，则编译器会自动定义一个无参的构造函数

                 方法名必须和类名一致

                 不能定义返回值类型不能在构造器里使用return返回某个值

          重载）

为了对象的初始化，我们需要创建构造器，通过new关键字调用构造器，有的时候要重载构造器，修改构造器中的参数，进行重载方法。

2.对象中机制

   2.1对象内存分析

          （建立虚拟内存模型

          程序运行的内存分析

          参数）

在Java中，敲代码是基础，我们还拥有读懂程序究竟是如何运行的，借助虚拟内存模型进行程序解读。

   2.2垃圾回收机制·

          （原理及算法

                 引用计算

                 根搜索）

在c语言中，需要人工删除我们不需要的程序，在Java中有垃圾处理机制，自动处理那些没有对象引用的栈帧或空间。处理掉我们多余的东西，节省内存空间。处理信息有两种方式引用计数和根搜索。创建大量无用对象；静态集合类的使用；监听器的使用等的操作都会导致信息泄露的操作。

3.编程三大特征

   3.1继承

          （概念＆实现

          接口运算符

          方法重写

          继承&组合）

继承有两功能：代码扩展，方便建模.可以让我们更好的对对象的建模，通过extends命令，可以进行子类和父类的继承，一个父类的继承是单继承，只有接口可以多继承。子类可以继承父类的属性和方法，除构父类构造方法不能继承，在进行实现时，要通过super关键字命令进行调用，并且super必须位于子类构造方法第一句。必要时，为了实现子类的方法还有进行父类方法的重写。在进行类型判断时，可以借助interfaceof来分别谁是谁都对象。

1.public
class TestA {

public static void main(String[] args) {

    Begain b = new End(2);

}

}

class Begain {

  int a;

  public Begain(int a) {

      System.out.println("构造器");

  }

}

class End extends Begain {

        End(int i) {//子类调用父类构造方法，先建立一个子类构造方法，在进行调用

            super(2);

        }

    }

2.public class Test{

     public static void main(String[ ]

args) {

              Student

s = new Student();

              System.out.println((s instanceof Student);//s是Student类的对象

     }

}

   3.2封装

          （作用&含义

          访问控制符

          javabean封装）

将更多的内部操作存放起来，留给人操作的东西越来越少，封装就是要把我们的代码装起来，只留下调用的方法。Java是使用“访问控制符”来控制哪些细节需要封装，哪些细节需要暴露的。访问控制符一共四类，分别是private，default,protected,public .protected运算符除其他包的类都可以访问。在javabean中属性控制符一般是private，使用set/get方法进行封装。

   3.3多态

          （概念＆实现

          对象转型）

多态就是一个方法，多个实现，比如中西吃饭方式就不一样了，在进行多态时，定义一个方法，进行子类继承，方法的重写，最后在main方法中父类地址指向子类对象，利用父类的引用，调用子类方法就形成多态。多态是方法的多态，与属性无关。

对象只能调用它编译的方法，不能调用它的运行方法，所以有时候需要进行向下转型(Animal
a=new dog();向上转型)

public class Dt {//有了多态，只需要让增加的这个类继承Animals类就可以了。

static void Animalcode(Animals a){//建立一个方法把父类的引用作为参数，之后调用子类方法

    a.speed();

    a.eat();

}

public static void main(String[] args) {

/* wolf w=new wolf();

 Animals a=w;*/

Animals a=new wolf();

Animalcode(a);//调用Animalcode（输入参数变量）

Animals a1=new tiger();

Animalcode(a1);



}

}

class Animals{//父类的继承，子类的重写方法

public void speed(){

    System.out.println("每小时最快速度：");

}

Animals(){

    System.out.println("Animals");

}



public void eat() {

    System.out.println("自然法则");

}

}

class wolf extends Animals{

public void speed()

{;//调用父类方法在子类方法中，不能在子类方法中调用父类构造器，要在子类构造器中调用父类构造器

    System.out.println("野狼每小时速度：70km");

}

public void eat(){

    System.out.println("会吃掉?");

}

}

class tiger extends Animals{

tiger(){

    super();

}

public void speep(){

    System.out.println("每小时120km");

}

public void eat(){

    System.out.println("老虎吃狼");

}

}

4关键字

   this关键字，表示当前对象，用构造器创造一个对象首写分配空间，初始化属性为0；进行属性赋值初始化，运行构造器，最后把地址付给相关变量。This就是创建后的对象的地址。在进行本类构造方法的调用时，位于构造方法的第一句。即使你不写this（）；，系统会自动帮你写上。

public class This {

public static void main(String[] args) {

    his t = new his(25, "小芸对象");

    System.out.println("小芸对象的对象" + t);

    t.user();

}

}

class his {

    int age;

    String name;

    public his(int age, String name) {

        System.out.println("正在给已经建好的属性进行初始化" + this);

        this.age = age;//前一个age为成员变量，后一个为局部参数

        this.name = name;//前一个name为成员变量，后一个是构造方法的局部参数

    }

    void user() {

        System.out.println(name + "正在输入小芸的对象");

    }

}







   static关键字，声明的成员属于静态属性，是类变量，被所有的对象共享，并且静态方法中不能访问属性。

   Super用与继承的子类方法中，用于调用父类普通方法，构造方法，必须位于方法的第一行。系统会默认Super（）；调用非空构造器需要输入参数super（参数）；。

   Final

为final修饰的方法，不能再重写，但可以重载。

为final修饰的类不能被继承。

为final修饰的变量，不能在被重新赋值。

5面对对象中的类

   5.1Object类

          （tostring方法

          ==&equals方法

          ==：是不是同一个对象

          Equals：逻辑上相等）

public class TestStringAgain {

public static void main(String[] args) {

    String s1=" sdfghjkl ";

    String s3="fgh";

    String s2=new String("sdfghjkl");

    System.out.println(s1==s2);

    System.out.println(s1.equals(s2));

运行结果如下：

false

true

   5.2抽象类

          抽象方法:只有方法声明，没有方法体，由abstract修饰。

   接口：接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了：规范和具体实现的分离。

抽象类还提供某些具体实现，接口不提供任何实现，接口中所有方法都是抽象方法。

abstract class Abstract1 {//抽象父类（可以有类的属性，方法,但一定要有构造器）

private int name;//私有属性

abstract void study();//抽象方法

abstract void test();//抽象方法

public int getName() {//封装

    return name;

}

public void setName(int name) {

    this.name = name;

}

}

class student extends Abstract1{//子类继承父类，并进行重写

 @Override

 void study() {

     System.out.println("好好学习天天向上");

 }

 @Override

 void test() {

     System.out.println("争取拿100");

 }

}

public class Abstract{

 public static void main(String[] args) {

     Abstract1 a = new student();//父类引用指向子类对象

     a.getName();

     a.study();

     a.test();

 }

}

5.3面向接口编程

静态方法与默认方法

我们可以在默认方法中调用静态方法，却不能再静态方法中调用默认方法，因为，静态方法属于类方法，不能调用非静态方法。

public class JingDong {

public static void main(String[] args) {

A a=new B();//父类引用指向子类对象

a.Mathod2();//此处a为对象，不能调用静态方法

B.Mathod1();//调用静态方法可用类名直接调用

}

}

interface A{//面向接口的编译过程

static void Mathod1(){

    System.out.println("第一个方法，静态方法");

}

default void Mathod2(){

    Mathod1();

    System.out.println("默认方法可以调用静态方法");

    System.out.println("第二个方法，默认方法");

}

}

class B implements A{//接口的实现，无法实现默认方法。

static void Mathod1(){

    System.out.println("通过接口实现静态方法");

}

}

接口的多继承

interface a{//接口类

void A();//抽象方法只有声明，无方法体

}

interface b{

void B();//抽象方法只有声明，没有方法体，方法体由子类接口实现

}

interface c extends a,b{

void C();

}

class Test implements c{//实现接口（implement），通过子类接口实现父类接口的方法

public void A(){

}

public void B(){

}

public void C()

}

}

5.4String类

          基础用法&常用方法

          常量池

          字符串相等的判断

下面是string类的常用使用方法。

public class TsetString {

public static void main(String[] args) {

   //判断字符串是否相等

    String s1="asdfghj";

    String s2 =new String("asdfghj");

    String s3="fg";

    System.out.println(s1==s2);//判断两个对象是不是同一个对象

    System.out.println(s1.equals(s2));//只要字符一致，就是一个对象（符合逻辑）

   ///

    System.out.println(s1.length());//打印字符串长度

    System.out.println(s1.charAt(5));//串打印字符的第n个字符是什么

    System.out.println(s1.indexOf(s3));//从左起，打印s3的第一个字符在s1中的第几个

    System.out.println(s1.lastIndexOf(s3));//从右开始，打印s3在s1字符串中的位置

    String s4="zxcvbnm".replace("cv","wer");//代替s4字符串中部分字符，代替个数大于一个

    System.out.println(s4);

    String s5="qwertyuiop".replace("w","d");//代替s5字符串的某一个字符

    System.out.println(s5);

    System.out.println("asdfghjkl".startsWith("ddgh"));//检查字符串是不是以某几个字符串开始

    System.out.println("asdfghjkl".startsWith("asdf"));//检查字符串是不是以某个字符串结束

    System.out.println("asdfghjkl".endsWith("jkl"));

    System.out.println(s5.substring(5,6));//截取字符串第4，5之间的字符

    System.out.println(s1.substring(6));//截取字符串某一个字符

    String s6="asdfgGHJ";

    System.out.println(s6.toUpperCase());//将字符串的小写字符转换成大写

    System.out.println(s6.toLowerCase());//将字符串的大写字符转成小写

    String s7=" c  d  ";

    System.out.println(s7.replace(" ",""));//利用replace代替字符串里的空格

    System.out.println(s7.trim());//删去字符串的起始及结尾的空格

}

}