黑马程序员_java面向对象学习笔记

------- android培训java培训、期待与您交流! ----------
1:面向对象


 (1)面向过程 强调过程,执行者
 (2)面向对象 强调对象,指挥者
 (3)面向对象思想的特点
  A:它是一种更符合人们思考习惯的思想
  B:它是复杂的内容简单化
  C:它是我们从执行者变成了指挥者

 (4)面向对象的特点
  A:封装
  B:继承
  C:多态


2:类和对象


 (1)类是对现实世界中事物的描述(属性和方法)
 (2)对象是现实世界中实际存在具体的个
  把事物转换成java语言描述。而java语言最基本的单位就是类。

  把事物对应的属性和行为分别替换成java语言中的成员变量和成员方法。
  举例:描述汽车
  class Car
  {
   String color;//属性
   int size;
   String type;

   public void run(){}//方法
   public void stop(){}
  }

 

3:局部变量和成员变量


 (1)作用范围
  局部变量:方法内
  成员变量:类中,对整个类有效
 (2)存储空间
  局部变量:栈内存
  成员变量:堆内存
 (3)初始化值
  局部变量:必须手动给值
  成员变量:默认初始化值。

4:匿名对象的使用

 (1)当对对象中的功能只执行一次的时候使用。否则,请你使用实名制对象。
  Person p = new Person();
  p.show();
  p.show();
  p.print();

  new Person().show();
  new Person().show();
  new Person().print();
 (2)用于作为实际参数进行传递。
  method(new Person());

  public static void method(Person p){}


5:封装


 (1)封装的好处:便于重复使用,安全性高。
 (2)private权限修饰符
  class Demo
  {
   private int age;
   //属性私有化后,我们可以对设置的值进行判断
   public void setAge(int age)
   {
    if(age>100 || age<0)
    {
     System.out.println("年龄有误");
    }
    else
    { 
     this.age = age;
    }
   }

   public int getAge()
   {
    return age;
   }
  }


6:构造函数


 (1)用途:用于创建对象,也有可能要进行初始化。
  A:格式 类名(){//code}
  B:Person(){}
 (2)特点 如果你没有建立构造函数,系统会自动建立一个空参构造,如果你建立了构造函数,系统就不会再建立构造函数了。
 (3)重载构造函数
  A:Person(){}
  B:Person(String name){}
  C:Person(int age){}
  D:Person(String name,int age){}

 注意:构造还可以用于给属性赋值。

7:this关键字


 (1)代表当前对象的引用。使用的时候,谁调用方法,this就代表谁。
 (2)this的使用:
  A:用于局部变量隐藏成员变量。
  B:写功能的时候,可能用到this。比如,compare()
  C:构造函数中使用this
   **this() 必须放在第一行。
  举例:
  Person(String name)
  {
   this.name = name;
  }

  Person(String name,int age)
  {
   this(name);//是找带一个字符串类型参数的构造方法
   this.age = age;
  }


8:代码块


 (1)局部代码块 提到代码效率
 (2)构造代码块 每new一次执行一次。
 (3)对象初始化:
  Person p = new Person();
  在内存中所做的事情:
  A:将Person.class文件加载到内存中。
  B:在堆内存中创建一个对象Person。
  C:把Person中的属性进行默认初始化。
  D:把Person中的属性进行显示初始化。
  E:调用构造代码块(如果没有,不执行这个操作)。
  F:调用构造函数进行初始化。
  G:在栈内存中声明Person类型的变量P。
  H:把堆内存的地址(引用)赋给了栈内存中P。

9:static关键字


 (1)静态的意思。可以修饰类的成员(成员变量和成员方法);
 (2)静态成员的特点:
  A:随着类的加载而加载,生命周期最长。
  B:优先于对象存在。
  C:被所有的对象所共享。
  D:比非静态成员多了一种访问方式。可以通过类名直接调用。而且建议这样做。
 (3)static的使用:
  当类中的成员需要被所有对象共享时,用static修饰。不需要被共享时,就不用static修饰。
  简单说:共性用static修饰,特性不用static修饰。(例如:饮水机和水杯。)
 (4)注意事项
  A:静态方法只能访问静态成员的。
  B:静态方法中不能使用this,super关键字。
  C:main是静态的。
   格式如下:
   public static void main(String[] args)
   {
    
   }

     ***由于它被jvm调用,所以权限要足够大,所以用public权限修饰符。
     ***为了jvm可以不用创建对象直接调用它,所以用static修饰。
     ***void jvm不需要任何返回。但是方法体结尾默认有return;
     ***main jvm只认识这个名字。
     ***String[] 有可能需要传入参数。
     ***args 字符串数组的名字,为了方便使用。
 (5)静态代码块
  类中加载流程:
  静态代码块--构造代码块--构造方法。

10:静态的应用


 (1)工具类ArrayTool的编译:
 因为使用的都是class文件。所以你应该先编译ArrayTool,然后在编译ArrayTest,最后执行ArrayTest。
 但是如果引用的工具类特别多的情况下,这样就很麻烦,所以java提供好的方式:只编译ArrayTest即可。
 (其实它首先在classpath下找ArrayTool.class,如果没有,接下来在当前类下找ArrayTool.class文件。
  如果还没有,它就会找ArrayTool.java文件,并且进行编译。如果都没有,就报错。)

 (2) 制作工具说明书:代码中有文档注释,用javadoc解析。
  javadoc -d arrayTool -author -version ArrayTool.java
  -d 后面跟目录
 (3) javadoc: 错误 - 找不到可以文档化的公共或受保护的类。
  改用public修饰一下即可


11:API(Application Program Interface):

应用程序编程接口。
 JavaAPI:java的帮助文档。

12:设计模式


 java中有23种设计。

 单例设计模式:保证类在内存中只有一个对象。
 
 如何保证类在内存中只有一个对象:
 (1)控制类的创建,不让外部类来创建类的对象。private
 (2)在本类中定义一个本来的对象。Student s;
 (3)提供公共的访问方式。  public static Student getInstance(){return s}

 单例写法两种:
 (1)饿汉式 一般开发用这种方式。
 class Student
 {
  private Student(){}

  private static Student s = new Student();

  public static Student getInstance()
  {
   return s;
  }
 }
 (2)懒汉式 一般不常用。
 class Teacher
 {
  private Teacher(){}

  private static Teacher t;

  public static Teacher getInstance()
  {
   if(t==null)
   {
    t = new Teacher();
   }
   return t;
  }
 }


13:继承(extends)


 (1)继承的体系结构:就是对要描述的事物进行不断的向上抽取,就出现了体系结构。
  A:先学习顶层内容,因为它是共性内容。
  B:一般使用的时候使用的是底层的类。
 (2)继承的好处:
  A:继承的出现,提高了代码的复用性。
  B:继承的出现,让类与类之间产生了关系,extends来表示,
     这个关系的出现,为后面我们讲面向对象的第三个特点多态打下了基础。
 (3)特点
  A:java只支持单继承(其实确切的说是java对多继承进行了优化,避免了安全问题)。
  B:java支持多重(层)继承。
 (4)注意:
  A:子类可以直接访问父类中的非私有的属性和行为。
  B:不要仅为了获取其他类中部分功能而去继承。
  C:类与类之间要有所属( " is a " )关系,xx1是xx2的一种。
   **如何判断A和B是否有继承关系?
   **A如果继承B,那么就可以说A是B的一种。

14:继承后子父类之间成员的关系


 (1)成员变量
  class Father
  {
   int num1 = 5;
  }

  class Son extends Father
  {
   int num1 = 20;
   int num2 = 10;
   
   public void show()
   {
    int num1 = 30;
    System.out.println("num1:"+num1);
    System.out.println("num2:"+num2);
    //局部范围内有的变量,如果我想使用成员变量,用this
    System.out.println("this num1:"+this.num1);
    //就想子类中访问父类中和子类同名的变量super
    System.out.println("father num1:"+super.num1);
   }
  }

  总结:使用子类中的成员变量时,首先看局部有没有和成员变量同名的,如果有就是用局部的。
        其实,在子类的成员变量里面找,如果有,直接输出。
        最后,在父类中找同名的变量,如果有,就输出父类的值。否则报错。

        this和super的区分:
        **this代表本类对象的引用
   super代表父类的内存空间的标识。
        **this可以用于区分局部变量和成员变量同名的情况。
   super可以用于区分子类和父类成员变量同名的情况。
        **一般,子类中不会出现和父类同名的成员变量。

 (2)成员方法
  class Father
  {
   public void show()
   {
    System.out.println("father show");
   }
  }

  class Son extends Father
  {
   public void show()
   {
    System.out.println("son show");
   }

   public void show1()
   {
    System.out.println("son show1");
   }
  }

  总结:在使用子类的成员方法时:首先在子类中找,其次在父类中找。否则,报错。
        super可以在子类中使用父类的成员方法。
   
   子类中存在和父类成员方法同名的这种现象,叫做重写,复写,覆盖。
   重写(override)和重载(overload)的区别:
   重载的特点:
    **在同一类中。
    **方法名相同,参数列表不同。
   重写的特点:
    **要有继承关系。在子父类中
    **方法的声明相同。(方法名和参数列表都相同)
     ***覆盖时,子类方法权限一定要大于等于父类方法权限
     ***静态只能覆盖静态。
 (3)构造方法
  class Father
  {
   
   Father(){}
   
   Fahter(int age)
   {
    System.out.println("father age:"+age);
   }
  }

  class Son extends Father
  {
   Son()
   {
    //默认这里有 super();
    //this(20);
    System.out.println("son");
   }

   Son(int age)
   {
    super(age);
    System.out.println("son age:"+age);
   }
  }

  Son s = new Son();  //father;son

  Son s = new Son(20);//father;son age:20

  总结:子类中所有的构造方法默认都会访问父类中空参数的构造方法。
   **因为每一个构造方法的第一行都有一条默认的语句super();

        当父类中没有空参数的构造方法时,子类的构造函数必须通过this
        或者super语句指定要访问的构造方法。类手动提供无参构造方法。

        this(...):调用本类中的构造方法
        super(...):调用父类中的构造方法

  构造方法用于创建对象,并进行初始化。
  
        class Person
        {
   Person(){}

   Person(int age)
   {
    this.age = age;
   }

   Person(int age,String name)
   {
    this(age);
    //this.age = age;
    this.name = name;
   }
        }

        //Person p =new Person();  //系统默认给出无参构造

        //当你手动给出构造方法后,系统就不会再给出默认的空的构造方法。

   
        如果想给属性赋值或者做一些初始化,手动写出无参数构造函数
   class Demo
   {
    private String name;
    Demo(){}

    public void setName(String name)
    {
     this.name = name;
    }

    public String getName()
    {
     return name;
    }
   }

 

15:final可以用来修饰的内容:


 (1)final可以用来修饰类:被fainl修饰的类不能被继承。
 (2)final可以用来修饰成员方法:被final修饰的成员方法不能被重写。
 (3)final可以用来修饰变量:被final修饰的变量为常量,值不能被修改。
    常量的命名规范:要求大写。
    final int PI = 3.14;

    final必须声明的时候就赋值。
    一般来说,是这样的。但是特殊情况:在构造方法可以给final修饰的变量赋值。

16:抽象类(abstract)


 (1)只抽取了很多类的方法的声明,为了保证不出问题,方法声明用abstract修饰。
 (2)抽象类的特点
  A:一个类如果有了抽象方法,那么这个类必须是抽象类。抽象类里边可以没有抽象方法。
  B:抽象类是不能够被实例化的。不能够创建对象的。
  C:如果一个类继承抽象类,那么,它要么实现抽象类中的所有抽象方法,
     要么本身也是抽象类。
 (3)抽象类的成员特点:
  A:成员变量:子类可以直接继承抽象类中的成员变量。(抽象类中的成员变量可以和以前是一样的)
  B:成员方法:抽象类中分为两种方法,一种是抽象方法,这种方法在子类中必须要被实现。
               一种是普通的方法。可以被子类直接继承使用。
  C:构造方法:抽象类不能被实例化,但抽象类是class,所以它有构造方法。
        它的构造方法用于让子类实例化。
 (4)抽象类的相关问题: 
  A:抽象关键字abstract不可以与下面的关键字共存
   **private
    ***私有的,外部直接无法访问。
   **static
    ***那么这个时候抽象方法就可以可以通过类名调用,但是这样是没有意义的。
   **final
    ***final修饰的方法不能被重写。所以它和abstract冲突。
  C:抽象类中可以没有抽象方法
   原因:防止其他类创建该类对象。


17:接口(interface)


 (1)接口的由来:当一个类中的方法都是抽象的时候,没必要定义为抽象类,
                定义为接口就可以了。
 (2)解决了java中只能单继承的问题。(对多继承进行了优化)
  A:类与类:只能是单继承。
  B:接口与接口:可以是单继承,也可以是多继承。
  C:类与接口:可以是单实现,也可以是多实现。
 (3)成员特点:
  A:只有成员变量和成员方法。
  B:成员变量 默认修饰符 public static final
   **int x = 20;
   **其实是这样的 public static final int x = 20;
  C:成员方法 默认修饰符 public abstract
   **void show();
   **其实是这样的 public abstract void show();
  注意:一般情况自己手动加上修饰符。
 (4)接口特点:
  A:接口是对外暴露的规则
  B:接口是功能的扩展
  C:接口降低了程序的耦合性。
   **内聚(自己实现功能的能力)
   **高内聚,低耦合。
  D:扩展说了下接口的理解
   **狭义的理解就是java中的接口。
   **广义的理解就是:任何定义的规范都是接口。
 (5)接口和抽象类的区别:
  A:抽象类只能被单继承;接口可以被多实现。
  B:抽象类中的成员:成员变量:可以是常量,也可以是变量。
       成员方法:可以是抽象的,也可以是非抽象的。
       构造方法:虽然不可以创建对象,但是可以给子类实例化用。
     接口中的成员:成员变量:只能是常量。默认修饰符 public static final
     成员方法:只能是抽象的。默认修饰符 public abstract
  C:抽象类中定义的是体系结构中的共性的内容。
     接口中定义的是对象的扩展功能。
  D:抽象类被继承表示的是:"is a"的关系。xx是yy中的一种。
     接口被实现表示的是: "like a"的关系。xx像yy中的一种。
 (6)举例:学生:Student
  A:属性:学号,姓名,年龄
  B:方法:学习(study),吃饭(抽象eat),抽烟或者不抽烟

  发现:在学生中定义抽烟的方法不合适。所以呢,我们另外用一个类来定义抽烟的方法。
        但是发现,如果用一个类描述抽烟的功能后,SmokeStudent是不能继承多个类的。
        这个时候,我们又得重写思考了。发现,抽烟的学生像一个抽烟的机器,所以,
        我们定义一个接口来放抽烟这个功能。
          interface Smoking
   {
   public abstract void smoking();
   }
  
    描述的是抽烟的学生:SmokeStudent extends Student implements Smoking

  SmokeStudent ss = new SmokeStudent();
  ss.eat();
  ss.study();
  ss.smoking();


18:多态


 (1)某一类事物的多种存在形态。
  **方法重载(静态多态)
  **方法重写(动态多态,对象多态)
 (2)对象多态的前提
  A:类与类(或接口)要有继承(或实现)关系。
  B:一定要有方法的重写。
  C:一定要有父类或者接口的引用指向子类的对象。
 (3)多态思想:可以指挥同一类型的一批对象做事情。多态的出现让我们复杂的问题简单化了。
  A:Animal Cat Dog
   **method(Animal a){a.eat();}
 (4)多态中成员的特点:
  Fu f = new Zi();
  A:成员变量:编译和运行都看Fu。
  B:非静态方法:编译看Fu,运行看Zi。
  C:静态方法:编译和运行都看Fu。
  
  举例: 动物的例子:
   向上转型
   Animal a = new Cat();
   a.eat();
   //a.catchMouse();

   向下转型
   Cat c = (Cat)a;
   c.eat();
   c.catchMouse();

   //向上转型
   Animal a = new Dog();
   //向下转型 转换异常
   //Cat c = (Cat)a;
   Dog d = (Dog)a;

   孔爹的例子:
   孔爹:教课(Java)
   孔子:教课(论语),看小说(),打游戏()。

   孔爹 k = new 孔子();//穿上他爹衣服,就跟着去了
   k.教课(论语)。
   //k.看小说();

   孔子 kz = (孔子)k;//把衣服脱了
   kz.教课(论语);
   kz.看小说();
   kz.打游戏();

19:Object


 (1)Object类:java中所有类的父类。它是java类体系结构中的根类。
       java中的类都直接或者间接继承自Object类。
 (2)Object里面的几个方法:重点掌握 toString(),equals()。
  A:boolean equals(Object obj)
     指示其他某个对象是否与此对象“相等”。
  B:String toString()
     返回该对象的字符串表示。
  C:int hashCode()
     返回该对象的哈希码值。
  D:Class<?> getClass()
     返回此 Object 的运行时类。
  E:protected void finalize() 了解
     当垃圾回收器确定不存在对该对象的更多引用时,由对象的垃圾回收器调用此方法。
     **final,finally,finalize
 (3)重点看下面两个方法
 //重写toString()方法
 public String toString()
 {
  //return "HelloWorld";
  return "name:"+name+",age"+age;
 }

 //重写Object的equals方法
 public boolean equals(Object obj)//s2--obj
 {
  //为了提高效率
  if(this == obj)
  {
   return true;
  }

  //为了程序的健壮性
  if(!(obj instanceof Student))//格式:对象 instanceof 具体的类名
  {
   return false;
  }

  Student s = (Student)obj;
  if(this.age==s.age)
  {
   return true;
  }
  else
  {
   return false;
  }
 }


20:内部类


 (1)将类A定义在另一个类B中。则类A就是内部类。
  A:什么时候使用内部类:有Outer和Inner两个类,当Inner想要直接访问Outer中的成员,
           而Outer需要建立Inner对象来访问Inner中的成员。这个时候,
           我们就可以把Inner定义为Outer的内部类。
  class Body
  {
   private class Heart()
   {
    //调用身体的其他部分
   }
  }
 (2)访问方式:
  A:内部类可以直接访问外部类中的成员,包括私有成员。
  B:而外部类要访问内部类中的成员必须要建立内部类的对象。
 (3)内部的存放位置
  A:成员位置
   **可以被private,static成员修饰符修饰。
   **被static修饰的内部类只能访问外部类中的静态成员。
  B:局部位置
   **也可以直接访问外部类中的成员。
   **同时可以访问所在局部中的局部变量,但必须是被final修饰的。
  
  Outer$Inner.class:$表示成员内部类。
  Outer$1Inner.class:$1表示它是一个局部内部类。
   ***因为局部内部类可以不写名字,所以带编号。

 (4)匿名内部类:没有名字的内部类。它是内部类的简化写法。
  A:前提:内部类可以继承或实现一个外部类或者接口。
  B:格式为:new 外部类名或者接口名(){覆盖类或者接口中的代码,(也可以自定义内容。)}
  C:简单理解:就是建立一个带内容的外部类或者接口的子类匿名对象。

  interface Inter
  {
   public abstract void show1();
   public abstract void show2();
  }
   
  //局部内部类
  class Outer
  {
   public void method()
   {
    class Inner implements Inter
    {
     public void show1()
     {
      System.out.println("show1");
     }

     public void show2()
     {
      System.out.println("show1");
     }
    }

    Inter i = new Inter();
    i.show1();
    i.show2();
   }
  }

  //局部的匿名内部类(重点)
  class Outer
  {
   public void method()
   {
    /*new Inter()
    {
     public void show1()
     {
      System.out.println("show1");
     }

     public void show2()
     {
      System.out.println("show1");
     }
    }.show1();

    new Inter()
    {
     public void show1()
     {
      System.out.println("show1");
     }

     public void show2()
     {
      System.out.println("show1");
     }
    }.show2();*/

    Inter i = new Inter()
    {
     public void show1()
     {
      System.out.println("show1");
     }

     public void show2()
     {
      System.out.println("show1");
     }
    };
    i.show1();
    i.show2();
   }
  }

 (5)匿名内部类的使用:
  A:通常在使用方法是接口类型参数,并该接口中的方法不超过三个时,
     可以将匿名内部类作为参数传递。增强阅读性。

21:异常


 (1)就是程序运行过程中,遇到了问题,这就叫异常。
 (2)异常的体系
  Throwable
   **Error
    ***通常出现重大问题如:运行的类不存在或者内存溢出等。
          不编写针对代码对其处理。
   **Exception
    ***在运行时运行出现的一些情况,可以通过try catch finally

 (3)Throwable
  A:getMessage() :返回此 throwable 的详细消息字符串。
  class Throwable
  {
   String detailMessage;
   Throwable(){}

   Throwable(String message)
   {
    this.detailMessage = message;
   }

   public String getMessage()
   {
    return detailMessage;
   }
  }
  B:toString():获取异常类名和异常信息,返回字符串。
  C:printStackTrace():获取异常类名和异常信息,以及异常出现在程序中的位置。返回值void。
 (4)处理异常处理方式:
  A:try...catch...finally
  格式:
   try
   {
    需要检测的代码;
   }
   catch(异常类  变量)
   {
    异常处理代码;
   }
   ...
   finally
   {
    一定会执行的代码;//释放资源 
   }
  变形:
   **try...catch(...)
   **try...finally
   **try...catch(...)...finally

  B:抛出 throws throw
  throws:用于标识函数暴露出的异常。thorws用在函数上,后面跟异常类名(可以由多个,用,隔开)。

  throw:用于抛出异常对象。throw用在函数内,后面跟异常对象。

  C:用哪一个比较合适:
   **你能处理,建议处理。try...catch...finally
   **你处理不了,抛出。

  D:自定义异常
   自定义类继承Exception或者其子类(RuntimeException)

   class MyException extends Exception
   {
    MyException(){}

    MyException(Stirng message)
    {
     super(message); //super是Exception里面的
    }
   }

   class Student
   {
    public void giveAge(int age) throws MyException
    {
     if(age>40 || age<0)
     {
      //throw new MyExcetpion("建议不学了");
      MyExcepiont my = new MyExcetpion("建议不学了");
      throw my;
     }
     else
     {
      System.out.println("符号要求,可以学习Java");
     }
    }
   }
  E:RuntimeException和Exception
   区别:RuntimeException就是要你改代码的。你可以不处理。

22:包


 (1)包:package
  A:对类文件进行分类管理
  B:给类提供多层命名空间
  C:放在程序代码的第一行(注释除外)

 (2)访问:先得到包,然后:包.类名
  如何解决手动创建包:
  javac -d xxx PackageDemo.java

  -d 后面跟的是:目录
  当前目录:.
 (3)不同包之间类的访问
  类一定要用全路径名称:包名.类名

23:protected


 包之间的继承关系。

24:import


 简化类名。
 一个程序文件中只有一个package,可以有多个import。
 用来导包中的类,不导入包中的包。
25:权限修饰符
  同一个类中     同一个包中 不同包中子类中    不同包中,不存在继承关系
private  OK    
默认  OK  Ok  
protected Ok  Ok  Ok
public  OK  Ok  OK   OK


26:关键字用来修饰:


  类 属性 方法 构造方法
private   OK OK OK
默认  OK Ok Ok OK
protected  Ok Ok OK
public  Ok Ok Ok OK
static   Ok Ok 
final  Ok Ok Ok 
abstract Ok  Ok 

特殊:private和static可以修饰内部类。
      static可以代码块。静态代码块。

 A:权限修饰符任意时刻只能使用一种。
 B:static,private,final 不能和abstract并用。

27:jar


 (1)打包:
  jar -cf haha.jar packa 
 (2)查看jar包
  jar -xvf haha.jar
 (3)如果内容特别多,好几个屏幕都放不下,
    假使我们能够通过某个命令,讲这些目录写入到一个记事本中。看起来就方便了。
  jar -tf haha.jar > c:\a.txt

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值