JavaEE基础编程语法--面向对象入手解析语法
目录
面向接口编程:接口可以作为函数的形参,实参是实现接口具体功能的子类
面向对象基础
对象创建内存
-
当程序运行到第一行代码的Book时,类Book就会进入方法区。运行到b1处,就会在栈里面创建一个内存Book b1 null(此时为空值)。
-
当程序运行到new Book()处,就会在堆内存里创建一个对象Book,并且这个对象的地址为0x1234,将地址返回给栈,作为b1的值。然后程序继续往下就是在堆内存中继续增加对象的属性及赋值等。
-
当程序运行到Book b2 =b1时,栈线上b1的上方创建b2,然后把b1的值复制给b2。
-
原理:实际上就是通过在栈存储的地址,找到堆内存中储存的对象,从而实现访问或修改对象。
-
当程序运行结束时,释放栈,b2先出栈,b1最后出栈,由于堆内存中的对象的地址没有被栈内存指向(对象不存在引用),满足GC的垃圾回收,堆内存 中的对象会被回收。
构造方法
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(1);
Person2 p1 = new Person2();
System.out.println(2);
p1.name = "张三";
p1.age = 18 ;
p1.say();
Person2 p2 =new Person2("李四",20);
p2.say();
}
}
class Person2{
//不建议程序员依赖程序自动生成的无参构造方法
//建议每创建一个对象就写一个构造方法
//构造方法的作用:用于对象初始化
//无参构造方法
Person2(){
System.out.println("构造方法执行了");
}
//有参构造方法
Person2(String a,int b){
name=a;
age=b;
}
String name;
int age;
void say() {
System.out.println("自我介绍:我是"+name+",我的年龄:"+age);
}
匿名对象
像m这种只使用一次的对象,我们可以用匿名对象将其进行替换。替换后效果如下:
匿名对象存储原理
-
如果一个对象,我们准备使用两次或以上,那么一定要给对象创建对象名。
每运行一个new Person5()就会创建一个新的对象,逻辑如下图
编程规范
面向对象进阶
封装Private
不封装程序会出现什么问题?类的成员属性容易被更改,导致输入一些不合逻辑的内容程序也能正常运行。如下面这张图,年龄被修改成负值,这是不符合实际事实的。
封装的意义:
-
保护或者防止代码(数据)被我们无意中破坏。
-
保护成员属性,不要让类以外的程序直接访问和修改。
封装原则
隐藏对象的属性和实现细节,只对外公开访问方法,并且控制访问级别。
在开发中,为了避免出现逻辑错误,我们建议对所有属性进行封装,并使用set()和get()方法进行修改和读取操作
(被省略掉的)this关键字
在编写方法时,我们通常希望方法的形参与类的属性名字相同,但是这样子程序会报错。下面给出了我们目标的赋值方式。
但这样的写法,实际形参只会给自己赋值,而不是给类的属性赋值
要解决这个问题,我们需要在被赋值的类属性前面加上this. ,this表示正在被创建/调用的对象。其实this一直在类属性前面,只是一般情况下程序会把this隐藏起来。
-
this 既可以调变量,也可以调函数方法。
-
在无参构造方法中调用this()可以实现无参调用有参构造方法
-
在一个构造方法中,调用另一个构造方法时,调用的代码 必须写在构造方法的第一行,否则会报错。错误实例如下
创建getter和setter的快捷键:shift+alt+s
Static
-
static属性的变量存储在方法区。
-
被static关键字修饰的方法或者变量不需要依赖于对象来进行访问,只要类被加载了,就可以通过类名去进行访问
-
可以这样去理解:把静态所修饰的属性看作是类的属性,是通过类去修改的;而非静态所修饰的属性看作对象的属性,是通过对象去修改的。
-
因为对象是在类创建后才创建的,而static的资源是在类创建(第一次使用类)的时候就被加载的,所以静态资源被调用的时机早于非静态资源。
-
第二次以后使用类都不会加载static的语句了!
-
在访问时: 静态不能访问非静态 , 非静态可以访问静态 !
Static方法
包
命名规范:通常由多个单词组成, 所有单词的字母小写, 单词与单词之间使用.隔开 ,一般命名为“com.公司名.项目名.模块名....”。
导包:import 包名.类名;
不用导的包:1.java.lang 2.当前包所含的其他类
权限修饰符
代码块
构造代码块
作用:在一个类中,我们通常定义多个无参/有参的构造方法,以便重载。但是如果在每一个构造方法里都需要一个固定的操作,我们需要在构造方法中加入相应的代码,有多少个构造方法就需要重复写多少条代码。而构造代码块就是将这个固定的操作放在一个块中,从而不用重复写。
/**
* 构造代码块,随着对象的每次创建,执行一次,且执行在构造方法之前
*
* 区别于构造方法的是:
* 无论用户调用哪一个构造方法来创建对象,构造代码块都必然执行
*/
//构造代码块
{
System.out.println("对象创建时执行1");
}
静态代码块
在类中使用static修饰的成员代码块, 我们称其为静态代码块, 在类加载时执行。 每次程序启动到关闭 ,只会执行一次的代码块。
/**
* 静态代码块,随着类的加载(第一次使用),静态代码块执行。
* 因为类只加载一次,所以静态代码块只执行一次。
*/
//静态代码块
static{
System.out.println("静态代码块执行");
}
面试题:
构造方法 与 构造代码块 以及 静态代码块的执行顺序: 静态代码块 --> 构造代码块 --> 构造方法
main方法详解
main()方法一直写到了今天:
public static void main(String args[])
以上的各个参数的含义如下:
· public:表示公共的内容,可以被所有操作所调用
· static:表示方法是静态的,可以由类名称直接调用。java StaticDemo09
· void:表示没有任何的返回值操作
· main:系统规定好的方法名称。如果main写错了或没有,会报错:NoSuchMethodError: main
· String[] args:字符串数组,接收参数的
public class StaticDemo10{
public static void main(String args[]){
for(int i=0;i<args.length;i++){
System.out.println(args[i]) ;
}
}
};
所有的参数在执行类的时候以空格进行分割。
java StaticDemo10 1 2 3 4 5 6 7
但是,如果现在我要输入的是以下几种参数“hello world”、“hello vince”、“hello mjw”
因为以空格分割,所以以上的三组参数会当做六组参数输入,那么此时如果要想完成有空格的内容输入,则参数需 要使用“"”括起来。
java StaticDemo10 "hello world" "hello vince" "hello mjw"
面向对象高级
继承
-
继承是java面向对象编程技术的一块基石,因为他允许创建分等级层次的类
-
继承就是子类继承父类的特征(类的属性)和行为(类的方法),使得子类对象(实例)具有父类的实例域和方法,或子类从父类是继承方法,使得子类具有父类相同的行为。
-
继承的限制:
-
java中只有单继承,多重继承(c继承b,b再继承a),没有多继承(多继承就是一个儿子有多个父亲)
-
-
格式
class 父类{ } class 子类 extends 父类{ }
子类实例化内存分析
-
当创建子类student的对象时,堆首先创建它的父类对象person,再创建子类的对象。然后再子类对象中通过super关键字存储父类的地址(相当于super把父亲引进来,使得父类成为子类的一部分)。
-
当子类调用方法时,先查看堆里的子类本身有没有这个方法或属性,如果没有,就往父类找。如此类推。
-
父类中只有被public或protected所修饰的属性或方法,才能被子类继承。
super关键字
-
通过super,可以访问父类的构造方法;默认通过无参构造方法访问,所以父类必须要有一个无参构造方法,否则会报错。调用super构造方法的代码,必须写在子类的第一行。在子类中,super就是被创建的父类对象。子类创建了多少个,就会自动创建多少个父类对象。
-
通过super,可以访问父类的属性
-
通过super,可以访问父类的方法
重写
重写规则:
-
1.参数列表必须完全与被重写方法的相同。
-
2.返回类型必须完全与被重写方法的返回类型相同。
-
3.访问权限不能比父类中被重写的方法的访问权限更低。例如,如果父类的一个方法被声明为public,那么在子类中重写该方法就不能声明为protected.
-
4.父类的成员方法只能被它的子类重写。
-
5.声明为static和private的方法不能被重写,但是能被再次声明
面试题
重写:重写子类继承父类的方法。
重载:一个类中有相同名称的但参数不同的函数
java中重写(override)与重载(Overload)的区别
-
1.发生的位置
-
重载:一个类中
-
重写:子父类
-
-
2.参数列表限制
-
重载:必须不同的
-
重写:必须相同的
-
-
3.返回值类型
-
重载:与返回值类型无关
-
重写:返回值类型必须一致
-
-
4.访问权限
-
重载:与访问权限无关
-
重写:子类的方法权限必须不能低于父类的方法权限
-
-
5.异常处理
-
重载:与异常无关
-
重写:异常范围可以更小,但是不能抛出新的异常。
-
final关键字
功能:用来定义常量
-
final用于修饰属性,变量。
-
变量变成了常量,无法对其再次进行赋值。
-
final修饰的局部变量,只能赋值一次。(可以先声明后赋值)
-
final修饰的是成员属性,必须在声明使赋值
-
-
final用于修饰类
-
final用于修饰方法
-
全局常量(public static final)
抽象类
不能被实例化
在抽象类的使用中有几个原则:
-
抽象类本身是不能直接进行实例化操作的,即:不能直接使用关键字new完成。
-
一个抽象类必须被子类所继承,被继承的子类(如果不是抽象类)则必须覆写(重写)抽象类中的全部抽象方法。
如果想对类的抽象部分进行实例化怎么办?
-
必须把抽象,模糊的部分明确(即编写一个子类,把原来在父类不能确定的部分在子类中确定下来。)这种操作称为重写抽象类中的抽象方法
抽象方法
只声明而未实现的方法称为抽象方法(未实现指的是:没有“{}”方法体),抽象方法必须使用abstract关 键字声明。
格式:
abstract class 类名{ // 抽象类
public abstract void 方法名() ; // 抽象方法,只声明而未实现 }
常见问题
1、 抽象类能否使用final声明?
不能,因为final属修饰的类是不能有子类的 , 而抽象类必须有子类才有意义,所以不能。
2、 抽象类能否有构造方法?
能有构造方法,而且子类对象实例化的时候的流程与普通类的继承是一样的,都是要先调用父类中的
构造方法(默认是无参的),之后再调用子类自己的构造方法。
抽象类和普通类的区别
1、抽象类必须用public或procted 修饰(如果为private修饰,那么子类则无法继承,也就无法实现其
抽象方法)。默认缺省为 public
2、抽象类不可以使用new关键字创建对象, 但是在子类创建对象时, 抽象父类也会被JVM实例化。
3、如果一个子类继承抽象类,那么必须实现其所有的抽象方法。如果有未实现的抽象方法,那么子类也必须定义为 abstract类
接口
概念
如果一个类中的全部方法都是抽象方法,全部属性都是全局常量,那么此时就可以将这个类定义成一个接口。
定义格式:
interface 接口名称{
全局常量 ;
抽象方法 ;
}
面向接口编程思想
这种思想是接口是定义(规范,约束)与实现(名实分离的原则)的分离。
优点:
1、 降低程序的耦合性
2、 易于程序的扩展
3、 有利于程序的维护
接口的实现 implements
接口可以多实现:
格式:
class 子类 implements 父接口1,父接口2...{
}
以上的代码称为接口的实现。那么如果一个类即要实现接口,又要继承抽象类的话,则按照以下的格式编写 即可:
class 子类 extends 父类 implements 父接口1,父接口2...{
}
全局常量和抽象方法的简写
因为接口本身都是由全局常量和抽象方法组成 , 所以接口中的成员定义可以简写:
1、全局常量编写时, 可以省略public static final 关键字,例如:
public static final String INFO = "内容" ;
简写后:
String INFO = "内容" ;
2、抽象方法编写时, 可以省略 public abstract 关键字, 例如:
public abstract void print() ;
简写后:
void print() ;
接口的继承
接口因为都是抽象部分, 不存在具体的实现, 所以允许多继承,例如:
interface C extends A,B{
}
注意
如果一个接口要想使用,必须依靠子类。 子类(如果不是抽象类的话)要实现接口中的所有抽象方法。
接口和抽象类的区别
1、抽象类要被子类继承,接口要被类实现。
2、接口只能声明抽象方法,抽象类中可以声明抽象方法,也可以写非抽象方法。
3、接口里定义的变量只能是公共的静态的常量,抽象类中的变量是普通变量。
4、抽象类使用继承来使用, 无法多继承。 接口使用实现来使用, 可以多实现
5、抽象类中可以包含static方法 ,但是接口中不允许(静态方法不能被子类重写,而接口中所以的方法必须要子类继承和重写,因此接口中不能声明 静态方法)
6、接口不能有构造方法,但是抽象类可以有
多态
概念
多态:就是对象的多种表现形式,(多种体现形态)
多态的体现
对象的多态性,从概念上非常好理解,在类中有子类和父类之分,子类就是父类的一种形态 ,对象多态性 就从此而来。
ps: 方法的重载 和 重写 也是多态的一种, 不过是方法的多态(相同方法名的多种形态)。
重载: 一个类中方法的多态性体现
重写: 子父类中方法的多态性体现。
instanceof关键字
作用:
判断某个对象是否是指定类的实例,则可以使用instanceof关键字
格式:
实例化对象 instanceof 类 //此操作返回boolean类型的数据
public static void say(Person4 p) { //面向接口编程:接口可以作为函数的形参,实参是实现接口具体功能的子类
//如何判断传入的对象 是此类型的哪种形态(哪个子类的对象)
/**
* 格式:
* 实例化对象 instanceof 类 //此操作返回boolean类型的数据
*
*/
if(p instanceof Student4) {
Student4 s = (Student4) p;
s.say();
}
else {
System.out.println("必须输入学生形态,才可以执行");
}
}
面向接口编程:接口可以作为函数的形参,实参是实现接口具体功能的子类
Object类
概念
Object类是所有类的父类(基类),如果一个类没有明确的继承某一个具体的类,则将默认继承Object 类。
例如我们定义一个类:
public class Person{ }
其实它被使用时 是这样的:
public class Person extends Object{ }
Object的多态
使用Object可以接收任意的引用数据类型,例子如下图
查看类的源码:放到类的位置上,然后用ctrl+鼠标左键
toString方法
建议重写Object中的toString方法。 此方法的作用:返回对象的字符串表示形式。
Object的toString方法, 打印对象时默认返回对象的内存地址 。如下图所示。
在类里面修改tostring方法(可以用shift+alt+s)之后,如下图
equals
与tostring一样,建议重写Object中的equals(Object obj)方法,此方法的作用:指示某个其他对象是否“等于”此对象。
Object的equals方法:实现了对象上最具区别的可能等价关系; 也就是说,对于任何非空引用值x和
y ,当且仅当x和y引用同一对象( x == y具有值true )时,此方法返回true 。
equals方法重写时的五个特性:
自反性 :对于任何非空的参考值x , x.equals(x)应该返回true 。
对称性 :对于任何非空引用值x和y , x.equals(y)应该返回true当且仅当y.equals(x)回报
true 。
传递性 :对于任何非空引用值x , y和z ,如果x.equals(y)回报true个y.equals(z)回报true
,然后x.equals(z)应该返回true 。
一致性 :对于任何非空引用值x和y ,多次调用x.equals(y)始终返回true或始终返回false ,前
提是未修改对象上的equals比较中使用的信息。
非空性 :对于任何非空的参考值x , x.equals(null)应该返回false 。
可以用shift+alt+s一键生成对应类默认的equals,一般无特殊需求建议用此方法进行equals改写。
内部类
概念
在Java中,可以将一个类定义在另一个类里面或者一个方法里面,这样的类称为内部类。
广泛意义上的内部类一般来说包括这四种:
1、成员内部类
2、局部内部类
3、匿名内部类
4、静态内部类
成员内部类
成员内部类是最普通的内部类,它的定义为位于另一个类的内部,形如下面的形式:
class Outer {
private double x = 0;
public Outer(double x) {
this.x = x;
}
class Inner { //内部类
public void say() {
System.out.println("x="+x);
}
}
}
特点:
-
成员内部类可以无条件访问外部类的所有成员属性和成员方法(包括private成员和静态成员)。
-
不过要注意的是,当成员内部类拥有和外部类同名的成员变量或者方法时,会发生隐藏现象,即默 认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员,需要以下面的形式进行访问:
-
外部类.this.成员变量
-
外部类.this.成员方法
-
内部类的应用:作为实现接口的子类。
注意:局部内部类就像是方法里面的一个局部变量一样,是不能有public、protected、private以及 static修饰符的。
匿名内部类
匿名内部类由于没有名字,所以它的创建方式有点儿奇怪。创建格式如下:
new 父类构造器(参数列表)|实现接口()
{
//匿名内部类的类体部分
}
注意:
在使用匿名内部类的过程中,我们需要注意如下几点:
1、使用匿名内部类时,我们必须是继承一个类或者实现一个接口,但是两者不可兼得,同时也只能
继承一个类或者实现一个接口。
2、匿名内部类中是不能定义构造函数的。
3、匿名内部类中不能存在任何的静态成员变量和静态方法。
4、匿名内部类为局部内部类,所以局部内部类的所有限制同样对匿名内部类生效。
5、匿名内部类不能是抽象的,它必须要实现继承的类或者实现的接口的所有抽象方法。
6、只能访问final型的局部变量
所有的局部内部类只能访问final型的局部变量
因为局部类是单独编译成一个.class文件,所有要使用a的话,具备了在编译成.class文件时,备份了a的值在.class文件中,但是由于局部类和主程序是编译成两个不同的.class文件,所以a必须是被final修饰的常量,否则a是常量的话,就会发生如果在主程序中a的值发生变化,而局部类中所用的a并没有及时改变,导致逻辑和程序出错。
简单来说,就是因为局部类被单独编译成.class文件,所以必须使用常量。
静态内部类
静态内部类也是定义在另一个类里面的类,只不过在类的前面多了一个关键字static。
静态内部类是不需要依赖于外部类对象的,这点和类的静态成员属性有点类似,并且它不能使用外部类的非 static成员变量或者方法.
包装类
存储原理
int 类型变量储存在栈中,Integer对象如下。
Integer包装类的好处:
-
可以作为函数的参数进行传递
-
Integer还有很多其他的方法可以进行整数操作,如Integer.parseInt(“"")方法,可以把字符串转化为相应的整型。
八种基本类型的包装类
概述
在Java中有一个设计的原则“一切皆对象”,那么这样一来Java中的一些基本的数据类型,就完全不符合于 这种设计思想,因为Java中的八种基本数据类型并不是引用数据类型,所以Java中为了解决这样的问题,引入了八种基本数据类型的包装类。
以上的八种包装类,可以将基本数据类型按照类的形式进行操作。
但是,以上的八种包装类也是分为两种大的类型的:
-
Number:Integer、Short、Long、Double、Float、Byte都是Number的子类表示是一个
数字。
-
Object:Character、Boolean都是Object的直接子类。
装箱和拆箱操作
以下以Integer和Float为例进行操作
-
将一个基本数据类型变为包装类,那么这样的操作称为装箱操作。
-
将一个包装类变为一个基本数据类型,这样的操作称为拆箱操作,
因为所有的数值型的包装类都是Number的子类,Number的类中定义了如下的操作方法,以下的全部方法都是进行拆箱的操作。
版本更新
查看类的结构:把鼠标放在类的位置上,然后按ctrl +T即可查看。
字符串转换
可变参数
一个方法中定义完了参数,则在调用的时候必须传入与其一一对应的参数,但是在JDK 1.5之后提供了新的 功能,可以根据需要自动传入任意个数的参数。
语法:
返回值类型 方法名称(数据类型…参数名称){
//参数在方法内部 , 以数组的形式来接收
}
注意:
-
可变参数只能出现在参数列表的最后
递归
递归,在数学与计算机科学中,是指在方法的定义中使用方法自身。也就是说,递归算法是一种直接或者间 接调用自身方法的算法。
递归流程图如下:
递归实现5的阶乘的程序分析
本文地址:https://blog.csdn.net/qq_36279562/article/details/108035938