黑马程序员--java基础--面对对象1

 

------- android培训、java培训、期待与您交流！ ----------

 

目录：1、类和对象的关系，2、 面对对象的三大特征（封装，继承，多态），3、面向对象(单例设计模式)，

1、类和对象的关系

类就是对现实生活中事物的描述

对象就是这类事物实实在在存在的个体

例如：描述汽车 其实描述事物就是在描述事物的属性和行为！

 class Car {//汽车颜色String color="红色";//汽车轮胎数int num =4;//运行行为void run(){System.out.println(color+"...."+num);}}

对汽车进行操作

class CarDemo{ public static void main(String[] args) {  //生产汽车，在java中通过new操作符或关键字来完成。  //怎么生产？其实就是在堆内存中产生个实体对象 Car c = new Car ();//通过Car类建立的对象，所以new Car然后产生了一个对象，这个对象里已经具备了轮胎数和颜色//为了好运算，所以给生产汽车起个名字，为Car c，这个时候c就是一个类类型变量，因为Car是一个类//记住： 类类型变量指向对象，类类型变量一定指向该类所产生的实体对象。//Car c = new Car();这个时候C为类类型变量，而类型为Car类型。/*需求： 将已有的车改成蓝色，就需要指挥该对象做事情，在java当中的指挥方式是： 对象.对象成员         比如：要改变车的颜色，语句就是 c.color = "要更改颜色";   想让车运行起来，就要调用车的运行方法*/    c.run();   Car c1 = new Car;   c1.run(); }}

 

匿名内部类：当对象的方法只调用一次时可以使用匿名内部类 这样比较简便，当进行多次调用时必须取个名字。

new Car.run();

2、 面对对象的三大特征（封装，继承，多态）

一.封装：

  封装其实就是在隐藏对象的属性和实现细节，仅对外提供公共的访问方式
 好处： 将变化隔离
               便于使用
              提高重用性
             提高安全性
  封装原则：
        将不需要对外提供的内容都隐藏起来
        将属性隐藏，提供公共方法对其访问
        函数就是java中最小的封装体

   封装--private

private:私有的（最小权限），权限修饰符：用于修饰类中的成员（成员变量，成员方法）
          私有只在本类中有效。
  注意：私有仅仅是封装的一种变现形式

 一个方法属性对应两个访问方式，一个是设置变量(set设置)
 另一个是获取变量（获取用get+变量名)

 之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句
 对访问的数据进行操作，提高代码的健壮性。

 封装原则：①、将不需要对外提供的内容都隐藏起来
                    ②、把属性都隐藏，提供公共方法对其访问
 

class Persion{ private int age; public static void getAge(int a) {  age = a; } public void setAge(int a); {  age = a; } public int getAge() {  return age; } void speak() {  System.out.println("age="+age); } class personDemo {  public static void main(String[] args)  {   Person p = new Person    p.setAge(20);    p.speak();  } }}

3、面向对象(单例设计模式)

设计模式：解决某一类问题最行之有效的方法。
 (单例设计模式,纯偏思想模式,java中有23种设计模式，称为jom设计模式)
  
   单例设计模式:解决一个类在内存中只存在一个对象。
   单例设计模式的写法：
   对于事物该怎么描述，还是怎么描述，当需要将该事物的对象保证在内存中唯一时，用单例设计模式
   有三部分写法：
   1 将构造函数私有化
   2 在类中创建一个本类对象
   3 提供一个方法,可以获取该对象

   想要保证对象唯一
   1 为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象
   2 还为了让其他程序可以访问到该类对象，只好在本类中自定义一个对象
   3 为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式

   这三部怎么用代码体现呢?
   1 将构造函数私有化
   2 在类中创建一个本类对象
   3 提供一个方法，可以获取该对象

方法被调用访问只有两种方式,一种是对象，另一种是类名，但是在单例模式中，只能存在一个对象，不能在new对象了
所以只能通过类名来调用，如果要通过类名要调用，单例模式中的成员方法要静态,静态方法要访问类中的成员
在此例中对象就是成员，所以成员也要静态

单例设计模式分两种（模式饿汗式，懒汉式）

饿汉式特点：
 类一进内存，就已经创建好了对象

在开发中，一般用恶汉式,因为饿汉式安全且简单

class Single{ //在本类中创建本类对象 private static Single s = new Single(); //将构造函数私有化 private Single(){} //提供一个对外访问的方法 public static Single getInstance() {  return s; }}

懒汉式：对象调用方法时，才初始化，也叫做对象的延迟加载，称为懒汉式，先执行getInstance方法，当方法一运行，才在内存中建立对象，

对象就会把地址值返回到方法区里的类变量，存在安全隐患。

class Single{ private static Single s = null; private Single(){}; public static Single getInstance() {  if (s==null)  {   s = new Single();   return s;  } }}

二 继承

 继承的特点：
1 提高了代码的复用性
2 让类与类之间产生了关系，有了这个关系，才有了多态的特性.
3 在java中只有一个父类，多个子类

千万不要为了获取其他类的功能，简化代码而继承，必须是类与类之间有所属关系才可以继承
所属关系是:：is a(谁是谁中的一员)

父类是子类的共性不断抽取而来的，所以先有子类。
什么时候考虑继承关系?
研究某种事物的时候，是不是另一个事物中的一种那个，使用继承关系
如果一个事物，继承了另一个事物，发现子事物中不应该具有，父类事物中的内容该继承无效

class Person{ String name; int age;}//学生是子类,Person为父类class Student extends Person{ private String name; private int age; public static void study() {  System.out.println("good study"); }}class Worker extends Person{ private String name; private int age; public static void work() {  System.out.println("good work"); }}

在java语言当中，只支持单继承，不支持多继承。

因为多继承容易带来安全隐患，当多个父类中定义了相同功能，内容不同时，子类对象不确定运行哪一个
 但是java保留这种机制，并用另一种体现形式来完成表示，叫做多实现。

查阅父类功能,创建子类对象使用功能

class C{ private void demo1(){};}class A{ private void demo1(){}; private void demo2(){};}//当B继承A的时候,他继承A的同时,同时也继承了demo2,所以B和A没有继承关系.class B extends A{ private void demo1(){}; private void demo3(){};}

子父类中的变量的特点

类中成员包含三个部分：
1 成员变量  (如果子父类中出现了，非私有的同名变量时，子类要访问本类中的变量用this
            那么子类要访问父类中的同名变量时，用super关键字，this关键字字和super关键字的引用是一样的)

2 成员函数 

3 构造函数

super：关键字
this：代表的是本来对象的引用
super：代表的是父类对象的引用

父类中私有的部分，不被子类所继承

class Fu{ int num1 = 4;}class Zi extends Fu{ int num2 = 5; void show() {  System.out.println(num); }}class ExtendsDemo2{ public static void mani(String[] args) {  Zi z = new Zi();  z.show();  //System.out.println(z.num1+"---"+zi.num2); }}

子父类中函数的特点-覆盖

当子类中出现了和父类一模一样的方法时，看上去好像是被覆盖一样
 这个也是方法的特性，叫做子类重写(覆盖)父类方法，覆盖要保证方法一模一样
 子类覆盖父类必须保证子类权限大于等于父类权限

    Public       protected       default         private

同一类中         是               是                  是                  是

同一包中         是               是                 是                   否

子类                 是               是                 否                   否

不同包中         是               否                 否                   否

重载和覆盖的区别：
     方法要一模一样，包括返回值类型都要一模一样! 重载是只看同名函数的参数列表。

覆盖：

静态覆盖静态，非静态覆盖非静态，只有方法才有覆盖!!!会运行子类函数的内容，如同父类的函数被覆盖一样。
这种情况就叫做重写，或者叫做覆盖！
当子类继承了父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能，但是子类的功能内容却和父类不一致
这时，没有必要定义新功能,而是使用覆盖特性，保留父类的功能复用，并重写功能内容。
重写还可用于扩展

子父类构造函数特点：
在运行子类构造方法之前，先运行父类构造方法，再运行子类构造方法！
 在对子类对象进行初始化时，父类的构造函数也会运行
 那是因为子类的构造函数默认第一行有一条隐式的语句 super()
 super()语句：会访问父类中空参数的构造函数，而且子类中所有的构造函数
 默认第一行都是super()；
注意：
1 super()语句要写到子类构造函数的第一行，因为先去父类初始化。
2 构造函数里要么有this语句，要么有super语句，两者只有其一！

结论：(这个结论其实是：子类的实例化过程 )
子类所有的构造函数，默认都会访问父类中空参数的构造函数，
因为每一个子类构造函数内的第一行，都有一句隐式的super()；
当父类中没有空参数的构造函数时，子类必须手动通过super或者this语句形式指定要访问父类中的构造函数
当然子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数,子类中至少会有一个构造函数
会父类中的构造函数。

 

class Fu{ Fu() {  System.out.println("fu run1"); }//如果下面再写一个有参数的构造函数,在子类对象调用的时候,跟它关系,因为没调用到. Fu() {  System.out.println("fu"+"run2"); }}class Zi extends Fu{//在子类的构造函数前有一个隐身的语句叫做,super() Zi() {  System.out.println("zi run"); }}class ExtendsDemo{ public static void main(String[] args) {  Zi z = new Zi(); }}//-------------------------------------------------------class Person{ private String name; Person(String name) {  this.name = name; } void show(){}}class Student extends Person{ Student(String name) {  super.name = name;  //也可以这样写 super(name); } void method() {  super.show(); }}

final：最终，是一个修饰符
 

 1 final关键字可以修饰类，方法，和变量
 2 final修饰的类不可以被继承(为了避免被继承，被子类复写功能，所以将类final)
 3 final修饰的方法不可以被覆盖
 4 final修饰的变量是一个常量，只能被赋值一次，既可以修饰成员变量，

   又可以修饰局部变量(final锁定的成员变量显示值，

    而不是成员变量默认值!)
 (当在描述事物时，一些数据的出现，值是固定的，这时为了增强阅读性都给这些值都给这些值起个名字方便于阅读
 而这个值不需要改变，所以加上final修饰，作为常量：常量的书写规范所有字母都大写，如果由多个单词组成，单词间通过下划线连接 
 以后在开发的时候，但凡数值是不变的，也要起个名字，加上final
 
 5 内部类定义在类中的局部位置上时，只能访问被final修饰的局部变量
 6 加上final后的变量，可以在构造函数内赋值，但是在一般函数中不能赋值！
   当常量final没赋值的时候，可以在构造方法中给final变量赋值！可以为final赋显示值，final修饰的变量只能修饰一次

 被final修饰的变量已变成常量,常量存在于方法区的常量池!
   继承的优点是减少了代码量，而弊端在于是打破了封装

 

------- android培训、java培训、期待与您交流！ ----------