Java学习第三阶段

我还想继续拖。

《封装》

隐藏实例细节，不让外部程序直接访问。

   看了几篇关于封装的博客，封装的作用通俗的来说：    
       1.提高代码的安全性。
       2.提高代码的复用性。
       因为提到程序设计追求的“高内聚，低耦合。”：封装细节，便于修改内部代码，提高可维护性，
       简化外部调用，编译调用者使用，便于扩展和写作。（这段话不是我讲的。）
       通过访问修饰符 private 封装属性，通过set和get方法设定和访问。（具体代码在二阶段）
       类中不需要对所有对外提供的内容都私有化，包括属性和方法。

---

但是私有仅仅是封装的体现形式而已。

《继承》

指在一个现有类的基础上去构建一个新的类。

    构建出来的叫子类，现有类叫父类，
    “ 子类会拥有父类所有可继承的属性和方法。 ”
  继承需关键字extends ：class 子类名  extends  父类名{}  代码如下。
  用处：也体现了代码的复用性，
              让类与类之间有联系，
              提供了多态的前提。
   tips ： 1. private 修饰的属性和方法不能继承。
           2.成员变量：如果子类和父类中出现了同名的成员变量，
                      访问父类要用super关键字，子类用this关键字（如果没有关键字默认是子类中的量）
           3.重写：a.当在程序中通过对象调用方法时，会先在子类中查找有没有对应的方法，
                     若子类中存在就会执行子类中的方法，
                     若子类中不存在就会执行父类中相应的方法。（官方说法）
                   b.如果子类中出现与父类一模一样的方法时，会出现覆盖操作，
                     就是override重写、复写、覆盖。
                     【注意：子类覆盖父类方法，必须要保证权限大于父类权限。
                            而且方法的返回值类型，方法名，参数列表都要一模一样。】       

    public  class   dad{
         String name；
         public void work（）{
         System.out.println("是爸爸。");      
   }
}

public  class son  extends  dad{
        public void  whatname(){
         System.out.println("name is"+ name);
   
   }
        public static void main(String[] args){
           son  n = new son();
           n.name ="th";
           n.work();
           n.whatname();
     }
}

输出的结果是 ：是爸爸 th
每个儿子只有一个亲爸爸，爸爸可以有几个儿子，子类只有一个父类。
好好记记访问修饰符范围
重写重载的区别：

重载：
对象：同一个类的不同方法中
1.参数必须不同，可以是类型，也可以是顺序
不规定返回值类型必须一样
2.可以有不同的权限修饰符
方法名必须一样，才能称方法与方法之间构成重载
3.可以抛出任意大小的异常
重写：
1.前提：重写（覆盖）必须发生在子父类之间，且只能是子类对父类的方法进行重写
2.参数列表必须和父类的一样
3.返回值类型需一致
4.权限修饰符子类需大于或等于父类方法权限修饰
子类抛的异常需不能大于父类抛出异常
————————————————
原文链接：https://blog.csdn.net/qq_34626097/article/details/83053004

Object ：Object类是所有类的父类，如果一个类没有使用extends关键字明确标识继承另外一个类，那么这个类默认继承Object类。

    1. toString()方法：Object类里面定义这个方法的时候返回的对象的哈希code码（即对象地址）
                       可以通过重写toString（）方法表示出对象的属性。
    2.equals()方法：比较的是对象的引用是否指向同一块内存地址（相同）。
                    当我们创建一个对象的时候，这个对象其实是一块内存地址，通过引用内存地址来修改属性。
                    一般情况下比较两个对象的内存空间是否相同，进行重写。
                    【使用方法：a.equals(b)，而且此方法返回值是布尔类型，1或者0】
                        

《多态》

Java作为面向对象的语言，同样可以描述一个事物的多种形态。

 比如：1.学生时人的一种，同学张三既是学生也是人。
       2.student类继承了person类，一个student的对象既是student，又是person。
         即Java中多态的代码体现在一个子类对象(实现类对象)既可以给这个子类(实现类对象)引用变量赋值
         又可以给这子类(实现类对象)的父类(接口)变量赋值。Student类可以为Person类的子类。
         那么一个Student对象既可以赋值给一个Student类型的引用，也可以赋值给一个Person类型的引用。
        【最终多态体现为父类引用变量可以指向子类对象。】
tips：  1.多态的前提是必须有子父类关系或者类实现接口关系，否则无法完成多态。
        2.在使用多态后的父类引用变量调用方法时，会调用子类【重写】后的方法。
抽象类：用abstract关键字修饰，则该类为抽象类 。
               应用：1.某些情况，父类只知道它的子类应该包含怎样的方法，
               但是没法准确知道这些子类如何实现这些方法。（约束子类必须有哪些方法）
                     2.从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板。
                     （避免了子类设计的随意性。）
        tips： abstract定义抽象类，定义抽象方法（只有声明，不需要实现。）
              【包含了抽象方法的类是抽象类。】
               a.抽象类中可以包含普通方法，也可以没有抽象方法。
               b.抽象类不能直接创建，可以定义引用变量。
                     

1）、普通类多态定义：父类类型 变量名 = new 子类类型（）；

//父类
	class Fu {}
	//子类
	class Zi extends Fu {}
	//类的多态使用
        Fu f = new Zi();

2）、抽象类多态定义：抽象类 变量名 = new 抽象类子类();

//父类
abstract class Fu {
            public abstract void speak(){
          };
	}

//子类
class Zi extends Fu {
            public void speak(){
	        System.out.println(“我是一号or其他号，继承说话模板”);
            }
 }

//测试
  Fu fu = new zi（）；
  fu.speak();

装箱与拆箱

   基本类型：boolean，char，btye，short，int，long，float，double
   基本类型包装类：Boolean，Character,Byte，Short,Integer，Long，Float，Double
  1. 装箱是指将基本数据类型封装为对象类型。
  2.拆箱是指将对象类型转换成基本数据类型。
  3.装箱和拆箱都是编译器自行完成的。
  4.装箱的实质是调用Integer.valueof()方法。

Integer num =10 ;//装箱
int i=num； //拆箱
//用int来对Long装箱时不行的，但是可以强制转换后再装箱
int i=10;
//false
Long l=i;
Long l=10；//默认整型时int类型
//ture
Long l =（long）i；

感谢学长的鞭策让我治好了多年的拖延症。