疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

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,方法重写与重载的区别?

  方法重写是在子类中对父类的方法重新实现一遍,即在子类中对父类中某方法的默认逻辑进行修改。方法名和参数列表都相同。

  方法重载是在一个类中,具有相同的方法名,但是参数列表不同的方法。