JavaNote3

class Life{     public static void main(String[] args){      int alive;          while(alive)          {              eat();                sleep();              code();              repeat();      }    }}

老人说,这不丢脸,也无损真正的骄傲.

面向过程(PO) C/Pascal

很早的编程思想, 站在过程的角度思考问题, 强调的是功能行为, 功能的执行过程, 即先干啥再干啥, 每一个功能用函数来实现, 使用某方法就调用该功能的函数.随着系统的膨胀, 面向过程将无法应付, 最终导致系统的崩溃, 为了解决这一问题, 前辈们就提出了面向对象思想.

面向对象(OO) C++/JAVA

一种基于面向过程的新的编程思想, 站在对象的角度思考问题, 把多个功能合理的放到不同对象里, 强调的是具备某些功能的对象.面向对象更加符合我们常规的思维方式, 稳定性好, 可重用性强, 易于开发大型软件产品, 有良好的可维护性.但是千万千万千万不要认为面向对象是优于面向过程的, 也不要带一门语言优于另外一门语言这种节奏.

1. 对象

   • 万物皆对象

   • 具有状态或行为

   • 创建对象: 类 对象名 = new new 类名()

   • 对象调用: 对象名.方法名([实参])

   • 对象比较: 同一个类, new 出来两个对象都会在堆里开辟不同的内存空间, new 一次 开辟一个新的空间, == 在比较引用类型的时候, 是在比较内存地址.

     public class JavaDemo1{public static void main(String[] args){    Demo demo1 = new Demo();    Demo demo2 = new Demo();    if(demo1 == demo2){        System.out.println("类的引用地址相同.");    }    else    {        System.out.println("类的引用地址不相同"); //执行这一句    }}}class Demo{}

   • 匿名对象: 没有名字的对象,就是创建对象时,没有赋给一个变量.new Demo();只在堆里开辟了内存, 不会被栈中的变量所引用, 只能使用一次.

2. 类(引用数据类型)

   • 具有相同特性 (数据元素) 和行为 (功能) 的多个对象的抽象.
   • 类是对象的模版/类型, 对象是一个个具体存在的个体.
   • 若类使用public修饰,则当前所在的文件名必须和类名相同.
   • 类型必须符合标识符的命名规范(使用名词,首字母大写).

3. 构造函数/构造器

   • 构造函数的名字必须和当前所在类的类名相同.
   • 无返回值, 也不定义返回值类型.
   • 当没有写构造函数时, 系统默认创建, 如果自己写了, 则不再默认创建.(当自己写构造函数的时候,一般会同时把无参构造函数也写上,构造函数的重载必须参数列表不同)

4. 修饰符

   • 访问修饰符
     
     • 默认的, 也称为default, 在同一包内可见,不使用任何修饰符.
     • 私有的, 以 private 修饰符指定, 在同一类内可见.
     • 共有的, 以 public 修饰符指定, 对所有类可见. main() 方法必须设置成公有的.
     • 受保护的, 以 protected 修饰符指定, 对同一包内的类和所有子类可见.
   • 非访问修饰符
     
     • static(静态) 修饰符
     • 随着类被加载进JVM而同时也最初始化和在内存中分配空间.
     • 修饰成员变量(字段),可以修饰方法等,就表面该字段或该方法属于类,而不属于某一个对象.
     • 它的加载时间是优于对象的, 对象是new 的时候才出来, 而static 是随着类.
     • 类名调用, 也可以用new 出来的对象(实例)调用, 但是源码还是类在调用,何必多此一举.
     • static修饰的方法只能访问静态方法或变量(没被static修饰的,要new才能被访问, 而static已经随着类的加载而诞生了, 难道访问一个没出身的?你要给你未出身的弟弟一块糖).
     • 一般在开发中工具类的工具方法都使用static修饰,直接类名调用就好了.
     • final 修饰符(终结者)
     • 修饰变量,则变量不能被修改.
     • 修饰方法,则方法不能被重写.
     • 修饰类, 则类不能被继承(断子绝孙符有木有).

5. 三大特征:

   • 封装(Encapsulation)

     • 概念: 指将对象的实现细节隐藏起来, 然后通过公共的方法来向外暴露该对象的功能.

     • 为什么要使用封装:

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

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

     • 可以对成员变量进行更精确的控制。

     • 隐藏信息，实现细节。

       // 封装简单democlass EncapsulationDemo{private String name;private String gender;private int age;public void setName(String name){    this.name = name;}public String getName(){    return this.name;}}

   • 继承(Inheritance)

     • 概念: 面向对象实现软件复用的重要手段, 当子类继承父类后, 子类是一种特殊的父类, 能直接或间接获得父类里的成员.

     • 特性:

     • 子类拥有父类非private的属性, 方法.

     • 子类可以拥有自己的属性和方法, 即子类可以对父类进行扩展.

     • 子类可以用自己的方式实现父类的方法.

     • Java的继承是单继承, 但是可以多重继承.

     • 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系）.

       class Animal {  private String name;    private int id;  /*动物都会吃, 和睡觉吧? 所以就写下方法, 但是方法体没写,因为不同动物吃的东西可能不一样*/ public void eat() {}   public void sleep() { } } class Dog extends Animal{ //只能有一个父类.String name = "Dog";public void eat(){ //重写父类的eat()方法    System.out.println("我正在吃骨头..");}}class Husky extends Dog{ //哈士奇继承狗类private String name = "Husky";public Husky(){    super(); // 默认调用父类对应参数的构造函数,和this一样,只能放在第一行,如果父亲还有父亲, 也要调用爷爷类的构造函数}public void variety(){    System.out.printxln("我的品种是哈士奇哦~可不是吉娃娃");}public void getName(){    System.out.pritnln("我的名字叫:"+ this.name +"我是"+super.name+"类中的特例");//super.name 调用父亲中的变量}}

   • 多态(Polymorphism)

     • 概念: 可以直接把子类对象赋给父类变量, 但是运行时依然表现出子类的行为特征, 这意味着同一类型的对象在运行时可能表现出不同的行为特征.

     • 优点:

     • 消除类型之间的耦合关系

     • 可替换性
     • 可扩充性
     • 接口性
     • 灵活性

     • 简化性

     • 说人话:

     • 使用父类类型的引用指向子类的对象.

     • 该引用只能调用父类中定义的方法和变量.

     • 如果子类中重写了父类中的一个方法, 那么在调用这个方法的时候, 将会调用子类中的这个方法.

     • 变量不能被重写（覆盖）,”重写”的概念只针对方法, 如果在子类中”重写”了父类中的变量. 那么在编译时会报错.

       public class Test { public static void main(String[] args) {   show(new Cat());  // 以 Cat 对象调用 show 方法   show(new Dog());  // 以 Dog 对象调用 show 方法   Animal a = new Cat();  // 向上转型(只能访问父类子类共有方法)   a.eat();               // 调用的是 Cat 的 eat   Cat c = (Cat)a;        // 向下转型 必须先向上转型   c.work();        // 调用的是 Cat 的 work}   public static void show(Animal a)  {   a.eat();       // 类型判断     if (a instanceof Cat)  {  // 猫做的事情          Cat c = (Cat)a;           c.work();       } else if (a instanceof Dog) { // 狗做的事情          Dog c = (Dog)a;           c.work();       }   }  }abstract class Animal {   abstract void eat();  }  class Cat extends Animal {   public void eat() {       System.out.println("吃鱼");   }   public void work() {       System.out.println("抓老鼠");   }  }  class Dog extends Animal {   public void eat() {       System.out.println("吃骨头");   }   public void work() {       System.out.println("看家");   }  }

     • 抽象类

     • 概念 : 如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类.

     • 说点人话 :

       • 关键字 abstract ,类的模版

       • 当类中有了抽象方法,该类必须为抽象类, 该类不能实例化.

       • 一个普通类继承了一个抽象类, 必须实现父类所有的抽象方法(或者声明自身为抽象类.),但是一个抽象类是可以不要抽象方法的.

       • 抽象类也是有构造函数的(好奇怪, 为什么会这样说, 因为等下还有个奇葩).

       • 抽象类不能实例化对象(所以说抽象类必须被继承,不然没有存在的意义), 其他功能和普通类一样.

       • 抽象类表示的也是一种继承关系, 一个类只能继承一个抽象类.

       • 抽象方法没有定义, 方法名后面直接跟一个分号, 而不是花括号.

       abstract class Person{abstract public void eat();  // 只是拿来当一个模版,人必须得吃饭睡觉,abstract public void sleep();// 除非 you are a robot.}class Sturdent extends Person{public void eat(){        //具体方法体}public void sleep(){}}

     • 接口(interface)

     • 这玩意儿绝对是一个奇葩, 但是真的很好用, 很难想象没有接口的Java是怎样的.

     • 概念 : 是一系列方法的声明, 是一些方法特征的集合, 一个接口只有方法的特征没有方法的实现, 因此这些方法可以在不同的地方被不同的类实现, 而这些实现可以具有不同的行为（功能）.

     • 先说人话:

       • 接口不是类, 但是和类是十分的相识, 不同的概念, 接口是一种标准.
       • 接口中只有常量(就算表面变量, 实质底层会自动转换为常量), 只有抽象方法(同样, 底层也会默认转换).
       • 一个类可以实现(implements)多个接口.
       • 接口可以降低类之间的耦合度(解耦).
       • 接口无法被实例化
       • 接口中的方法是不能在接口中实现的, 只能由实现接口的类来实现接口中的方法(接口只是制定一种标准)
       • 没有构造函数,没有构造函数,没有构造函数.(奇葩)
       • 一个接口能继承另一个接口, 这和类之间的继承比较相似.

     • 抽象类和接口的区别

       • 抽象类中的方法可以有方法体, 就是能实现方法的具体功能, 但是接口中的方法不行.
       • 抽象类中的成员变量可以是各种类型的, 而接口中的成员变量只能是public static final 类型的.
       • 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法), 而抽象类是可以有静态代码块和静态方法.
       • 一个类只能继承一个抽象类, 而一个类却可以实现多个接口.

       class Animal{void walk(){}void swin(){}}interface IWalkable{void walk();}interface ISwinable{void swin();}class Cat extends Animal implements IWalkable{public void walk(){    System.out.println("猫是会走路的...");}}class Fish extends Animal implements ISwinable{public void swin(){    System.out.println("鱼是会游泳的...");}}class Frog extends Animal implements ISwinable, IWalkable{public void walk(){    System.out.println("青蛙是跳着走路哒~");}public void swin(){    System.out.println("青蛙是会蛙泳的哟~");}}class _接口练习 {public static void main(String[] args) {    IWalkable c = new Cat();    IWalkable f = new Frog();    c.walk();    f.walk();    ISwinable f1 = new Frog();    f1.swin();    Animal f2 = new Frog();    f2.walk();    f2.swin();}}

CNcots CN Caprice of the stone的简写, 译为石头的随想曲.

博客中有网上摘抄的资料. 有个人的一些小心得 ,有什么不对的地方, 还请各位观客老爷们指出.

JavaNote系列博客, 纯属个人学习时间段整理的一些笔记, 会坚持每周至少一更,多多关照.