我要评论
目录
面向接口编程：接口可以作为函数的形参，实参是实现接口具体功能的子类
面向对象基础
对象创建内存
-
当程序运行到第一行代码的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
您可能感兴趣的文章:
如您对本文有疑问或者有任何想说的，请点击进行留言回复，万千网友为您解惑！
网友评论