• 初学Java6:Java OOP基础语法总结



    *************** Java OOP 基 础 语 法 总 结 *************************
    1,类与对象
    1),类(class)是相同属性和方法的一组集合。
    A,类的组成:属性和方法。
    B,语法声明:使用class关键字,eg:public class Student{}//类名首字母大写,且必须和文件名一致
    C,类的实例化:使用new关键字,eg:Student student=new Student();//声明一个Student类型的变量or实例化一个Student对象
    D,类与文件的关系;
    a,一个java文件可以包含多个java类
    b,一个java文件最多只能有一个public类
    c,java文件的名称必须和其中的public类名一致
    E,eg:public class Student{//类(首字母大写)
    public void getName(){//方法(一般为动词+名词,动词首字母小写,名词首字母大写)
    String name;//属性(数据类型+属性名)
    }
    }
    2),对象(object)是一个具体的实体(entity)。
    eg:某某学生即可作为一个对象
    ********************************************************************
    2,方法
    1),可以重复执行的代码块,对于调用者来说相当于一个“黑盒子”。
    2),语法声明;访问控制修饰符 返回值类型 方法名 (参数列表){
    方法体;
    }
    eg:public void getName(int num){
    String name;
    }
    3),方法的传参--数据类型:A,8种基本数据类型(byte,int,short,long,float,double,char,boolean)
    B,引用数据类型(eg:Student student=new Student();中的student就是引用数据类型)
    注:基本数据类型与引用数据类型的区别:
    a,存储方式不同,基本数据类型存在 栈 中,是按值传
    引用数控类型存在 堆 中,是按址传
    b,使用方式不同,基本数据类型 无属性和方法
    引用数控类型 有属性和方法
    ********************************************************************
    3,构造方法(Constructor)
    1),是一个特殊的方法,该方法的作用是实例化对象,会在内存中分配空间,且可以对类的属性进行初始化
    2),语法特征:
    a,构造方法的名字必须与所在的类一致
    b,没有返回值类型,注意和没有返回值不是一回事
    c,默认情况下有一个隐式的无参构造方法,其访问控制修饰与所在的类的访问控制修饰一致
    d,如果我们自定义了构造方法,则隐式无参构造方法就不存在了
    3),使用方法:使用new关键字调用

    ********************************************************************
    4,包(package)
    1),意义:解决命名冲突
    2),命名:主要需要知道域名反写,全部字母小写,不能以数字开头,eg:com.baidu.zhidao.azhi0828//合法包名
    3),如果一个类需要使用另一个包中的类,需要使用import关键字导入相应的包,其中java.lang无需显式导入
    ********************************************************************
    5,可变长度参数
    1),是在数据类型后面加上“...”表示,当成数组。
    eg:int getTotal(int...num){
    代码块;
    }
    2),调用时可以不传参数,可以传若干参数,传入参数用逗号隔开,也可以传入数组。
    3),一个方法最多只能有一个可变长度参数,而且必须放在最后位置
    eg:eg:int getTotal(int num1,int...num2){
    代码块;
    }
    ********************************************************************
    6,命令行参数
    ***了 解***
    ********************************************************************
    7,方法重载
    1),在一个类中,具有相同的方法名,但是参数列表不同的方法。
    2),可分为一般方法重载和构造方法重载。
    eg:class Student{//同一个类
    void getInformation(String name){//相同的方法名,不同的参数列表
    ***;
    }
    void getInformation(int age){//相同的方法名,不同的参数列表
    ***;
    }
    }
    ********************************************************************
    8,this关键字
    (1),使用环境:方法和构造方法中。
    (2),使用方法两种:
    1),this.属性(方法);//this表示当前运行的实列(对象),注意:this未运行时,不代表任何属性(方法)。
    2),this();//只能用在构造方法中。表示调用其他重载形式的构造方法,而且必须放在第一行。
    (3),注意:静态方法中不能使用this!(静态方法属于类,不是实列,而this代表了当前运行的实列,放一起顺序会逻辑混乱),main中也不能使用this!
    (4),eg:
     1 package com.zhi.java.course;
     2 public class Text{
     3     Text(int num){//this();只能用在构造方法中
     4         this.num=num;
     5     }
     6     Text(){
     7         this(100);//无参方法调用有参
     8     }
     9     int num=1;
    10     int getNum(){
    11         return num;//此处可以直接放回num
    12     }
    13     void setNum(int num){//新定义的num不同于成员变量num
    14         this.num=num;//此处this不可省
    15     }
    16     void m1(){
    17         
    18     }
    19     void m2(){
    20         this.m1();//此处this可以省
    21     }
    22      static void m3(){
    23         System.out.println(this.num);//Error!Cannot use this in a static context
    24     }
    25 }
    ********************************************************************
    9,super关键字(对比this关键字)
    (1),使用环境:一般的实列方法中和构造方法中
    (2),使用方法两种:
    (1),super.属性(方法);//调用父类的属性(方法)
    (2),super();//只能用在构造方法中。表示调用父类相应的构造方法,而且必须放在第一行。
    ********************************************************************
    10,final关键字
    (1),final修饰类,表示该类不能再被继承;
    eg:final class Animal(){}//Animal不能再被继承。
    (2),final修饰变量,该变量必须被赋值,final修饰后该变量变为常量,不能再改变;
    eg:final int num=10;//num不可再改变。
    (3),final修饰方法,该方法不能再被重写;
    eg:final void m1(){}//方法m1在f父类,在子类中final不能再被重写。
    (4),final修饰属性,1),可以直接在声明时赋值
    2),可以在代码块中赋值
    3),静态的可以在静态代码块中赋值
    ********************************************************************
    11,继承
    (1),概念,继承是OOP特征之一,是子类通过继承获取父类中的部分属性和方法。
    (2),使用extends关键字
    1),符合is-a关系的设计使用继承
    2),继承是代码重用的一种方式
    (3),好处:1),做到代码重用
    2),系统维护性更好。
    (4),不能继承的有:1),子类不能继承父类的构造方法。
    2),子类不能继承父类的私有方法(private)。
    3),子类和父类不在同一包,使用默认的访问权限的成员
    (5),eg:
     1 package com.zhi.java.course;
     2 public class Animal {
     3     String name;//公共的属性或方法
     4     int age;
     5 }
     6 public class Dog extends Animal {//继承父类的属性,一个子类只能继承一个父类(单根继承)
     7     public static void main(String[] args) {
     8         Dog dog = new Dog();
     9         dog.name = "大黄";
    10         dog.age = 300;
    11         String na= "田不易";//也可以有子类的特有属性(方法)
    12     }
    13 }

    ********************************************************************
    12,类的初始化顺序:(从上到下)
    父类的静态代码块
    子类的静态代码块
    父类的代码块
    父类的构造方法
    子类的代码块
    子类的构造方法
    注意:静态代码块只能执行一次!
    ********************************************************************
    13,访问控制修饰符
    1),概念,a:Java提供四种访问控制修饰符(public private 包 )
    b:放在方法与变量前,部分访问控制修饰符也可以放在类前
    c:目的是控制代码的访问权限。
    2),控制范围(从大到小)
    public 所有代码都可以访问
    protected 本类,包及其子类的代码可以访问
    包 本类,同一个包中访问
    private 私有的,它修饰的属性,方法,或内部类只能本类使用

    ********************************************************************
    14,方法重写
    1),概念:在子类中对父类的方法重新实现一遍,即在子类中对父类中某方法的默认逻辑进行修改。
    2),语法:a,方法名一样
    b,方法的参数一样
    c,子类重写的方法返回值类型要与父类返回值类型一样或者是其子类
    d,子类访问控制修饰符的范围不能比父类不能小
    e,子类抛出的异常不能比父类抛出的异常多或范围更大
    3),以下方法不能重写:
    a,private方法
    b,构造方法(Constructor)
    c,static方法
    d,final方法
    ********************************************************************
    15,Object类
    (1),java是单根继承,在java中不允许多根继承。
    (2),Object是所有类的最终父类,所有类或者是数组都可以直接或间接继承Object类。
    (3),Object类来自java.lang包。
    (4),可以将所有的引用类型值赋给Object类型声明的变量,包括null。
    (5),Object提供9中可用方法,所有的子类都都可以使用,其中
    getClass(),notiFy(),notiFyall(),wait()不可以被子类重写
    toString(),equals(),hashCode(),clone(),finalize()可以被子类重写
    (6),toString()方法
    1),自动调用toString()方法的场景:字符串拼接和控制台输出,如下列:
     1 package com.zhi.java.course;
     2 public class Dog {
     3     String name;
     4     int age;
     5     public String getName() {
     6         return name;
     7     }
     8     public void setName(String name) {
     9         this.name = name;
    10     }
    11     public int getAge() {
    12         return age;
    13     }
    14     public void setAge(int age) {
    15         this.age = age;
    16     }
    17     public static void main(String[] args) {
    18         Dog dog = new Dog();
    19         dog.setName("大黄");
    20         dog.setAge(300);
    21         System.out.println(dog);//等同于System.out.println(dog.toString());会自动调用toString方法,故有以下结果
    22     }
    23 }
    运行结果: com.zhi.java.course.Dog@2a139a55 //默认实现输出格式:全限定类名@哈希码的16进制 

    2),重写toString()方法
     1 package com.zhi.java.course;
     2 public class Dog {
     3     String name;
     4     int age;
     5     public String getName() {
     6         return name;
     7     }
     8     public void setName(String name) {
     9         this.name = name;
    10     }
    11     public int getAge() {
    12         return age;
    13     }
    14     public void setAge(int age) {
    15         this.age = age;
    16     }
    17     @Override//重写注解,可判断是否重写
    18     public String toString() {
    19         return "名字:"+name+"
    年龄:"+age;  //重写获得需要的值
    20     }
    21     public static void main(String[] args) {
    22         Dog dog = new Dog();
    23         dog.setName("大黄");
    24         dog.setAge(300);
    25         System.out.println(dog);//等同于System.out.println(dog.toString());已经重写toString()方法
    26     }
    27 }
    运行结果:名字:大黄
       年龄:300
    (7),equals()方法重写
    1),当类有逻辑上的等同意义而不仅是对象意义上的等同时 需要重写equals()方法。
    2),以下情况不能重写:
    a,每个类实列本质上是唯一的。
    b,不关心类是否提供了“逻辑意义上的等同”测试。
    c,超类已经重新了equals,该方法也适合子类。
    3),回顾 "==":比较基本数据类型的值是否相等(按值比较),比较引用数据类型是否是同一个对象(按址比较)。
    equals:默认与"=="相同,重写可自定义比较规则。
    4),未重写时结果如下:
     1 package com.zhi.java.course;
     2 class Game {
     3     private String name;
     4     private int age;
     5     public String getName() {
     6         return name;
     7     }
     8     public void setName(String name) {
     9         this.name = name;
    10     }
    11     public int getAge() {
    12         return age;
    13     }
    14     public void setAge(int age) {
    15         this.age = age;
    16     }
    17 }
    18 public class EqualsJob {
    19     public static void main(String[] args) {
    20         Game g1 = new Game();
    21         g1.setName("LOL");
    22         g1.setAge(6);
    23         Game g2 = new Game();
    24         g2.setName("LOL");
    25         g2.setAge(6);
    26         System.out.println(g1.equals(g2));// 用equals直接比较两个相同的引用类型,等同System.out.println(g1==g2);
    27     }
    28 }
    运行结果:false
    5),重写equals()后如下:
     1 package com.zhi.java.course;
     2 class Game {
     3     private String name;
     4     private int age;
     5     public String getName() {
     6         return name;
     7     }
     8     public void setName(String name) {
     9         this.name = name;
    10     }
    11     public int getAge() {
    12         return age;
    13     }
    14     public void setAge(int age) {
    15         this.age = age;
    16     }
    17     @Override
    18     public boolean equals(Object obj) {
    19         if (this == obj) {
    20             return true;
    21         }
    22         if (obj instanceof Game) {//向下转型需要通过instanceof判断obj和Game是否同一类型
    23             Game g = (Game) obj;//类型一致则强转类型,向下转型
    24             return g.getAge() == age && g.getName().equals(name);//自定义比较规则
    25         }
    26         return false;
    27     }
    28 }
    29 public class EqualsJob {
    30     public static void main(String[] args) {
    31         Game g1 = new Game();
    32         g1.setName("LOL");
    33         g1.setAge(6);
    34         Game g2 = new Game();
    35         g2.setName("LOL");
    36         g2.setAge(6);
    37         System.out.println(g1.equals(g2));// 使用equals直接比较两个相同的引用类型
    38     }
    39 }
    运行结果:true
    6),equals()重写约定
    a,自反性
    b,对称性
    c,传递性
    d,一致性
    e,任何非空x,x.equals(null)总是false
    f,重写equals方法时永远要重载hashCode方法
    ********************************************************************
    16,向上转型与向下转型:
    (1),向上转型:子类的实例可以自动转换为父类的类型
    (2),向下转型:父类型需要强制转化为子类型,前提是该对象本身就是子类型的对象,使用instanceof做判断
    ********************************************************************
    17,抽象类:
    (public abstract class shape{}就是一个抽象类)
    (1),使用abstract声明抽象类或抽象方法
    (2),抽象类可以有抽象方法,也可以没有抽象方法,但是抽象方法必须在抽象类中
    (3),抽象类不能实例化
    (4),抽象类可以有构造方法
    抽象方法:(public sbstract void sss();就是一个抽象方法)
    (1),没有实现体
    (2),不能被final,private,static修饰
    (3),主要给子类来重写的

    如果抽象类的子类是一个具体的类,该具体类必须实现父类的所有抽象方法
    如果子类也是抽象类,子类既可以实训父类的抽象方法,也可以不实现
     ********************************************************************
    18,接口
    (1),概念:它是一个纯粹的抽象类,其它的方法全部都是抽象方法。它是一种约定,一种能力
    (2),声明语法:使用interface关键字,eg:public interface Swimable{}
    1),可以声明属性,该属性默认是public static final修饰的,必须赋初始值
    2),可以有方法,全部是抽象方法,
    3),接口不能直接实例化(接口是一个纯粹的抽象类)
    (3),接口成员-常量属性
    1),接口中所有的属性都是public static final修饰的
    2),常量可以是基本数据类型,也可以是引用数据类型
    (4),注意:1),常量的命名规范是全部字母大写,eg:public static final int NUM=10;
    2),接口的修饰符可能是包级访问级别的,所以public常量有可能访问不到
    3),推荐使用枚举保存一组相关的值(至少java5)
    (5),继承接口
    1),接口可以使用extends关键字继承另一个接口
    2),可以继承:抽象方法和默认方法,常量属性,嵌套类型
    3),不能继承静态方法
    (6),实现接口
    1),实现接口的具体类需要使用implements关键字,并且需要重写接口中所有的抽象方法。eg:public class Fish implements Swimable{}
    2),实现接口的抽象类可以重写接口中的部分抽象方法。
    3),一个类可以实现多个接口,但是只能继承一个类,而且应先继承后实现。
    4),接口可以作为数据类型用来声明变量。
    5),接口也可以继承接口。
    ********************************************************************
    19,面向对象的三大特征:封装,继承,多态
    (1),封装:将实现的代码或属性放在一个类或方法中,不让外部代码随意访问。
    好处:安全。
    使用访问控制修饰符 private
    (2),继承:子类会将父类的部分属性或方法继承下来。
    好处:做到代码重用,提高系统的维护性能
    使用关键字:extends
    (3),多态:在不同的场景下,类或方法有不同的指向。
    好处:代码量可以减少
    体现:1),方法上的多态:重写和重载
    2),类的多态:类作为方法的参数或返回值类型
    ********************************************************************
    20,接口与抽象类的区别?
    1),语法上,接口是使用interface声明,使用implements实现,
    抽象类是使用abstract声明,使用extends继承。
    2),特定,接口不能有具体的方法,属性都是静态常量,
    抽象类可以有构造方法、抽象方法、普通方法,还有属性。
    3),设计上,表达某种能力使用接口,

    ********************************************************************
    21,方法重写与重载的区别?
    方法重写是在子类中对父类的方法重新实现一遍,即在子类中对父类中某方法的默认逻辑进行修改。方法名和参数列表都相同。
    方法重载是在一个类中,具有相同的方法名,但是参数列表不同的方法。
                                                      
       为了这个东西,从早上10点弄到现在,除了中午下午吃饭时间,一直没间断,好累...
                                                       A_zhi
    							                2016/8/28/22/50
    ******************** 持 续 修 改、补 充... ***************************
     
  • 相关阅读:
    RabbitMQ入门-Topic模式
    RabbitMQ入门-路由-有选择的接受消息
    RabbitMQ入门-发布订阅模式
    RabbitMQ入门-竞争消费者模式
    RabbitMQ入门-队列
    Windows下安装RabbitMQ
    ThymeLeaf的eclipse插件安装
    Freemarker 的 Eclipse 插件 安装
    MySQL基础学习笔记
    我是不是一个不愿意自己多努力,还老是跟别人吐槽公司这不好那不好的人
  • 原文地址:https://www.cnblogs.com/a-zhi/p/5816256.html
Copyright © 2020-2023  润新知