目录
最基本的语法
基本语法和C语言大致类似
用一个程序为例子
利用矩阵快速幂来优化斐波那契数列
import java.util.*;//引入一个库
///地推实现矩阵快速幂
public class Fibonacci {
public static void main(String[] args) {
//一个扫描器对象，用于接受键盘数据，需要引用java.util.Scanner库
Scanner sc = new Scanner(System.in);
if (sc.hasNext()) {//使用hesNext方法来判断用户有没有输入下一个字符
long n = sc.nextLong();//使用nextLong方法，将输入的值转化为长整型储存
System.out.println(fast_mod(n));//输出函数
}
}
public static long[][] multi(long[][] ans,long[][] base){
long[][] temp; //数组声明的方式，建议使用这一种声明方式，还有一种方式是和C语言一样的方式
temp=new long[2][2];//利用new来创建一个数组
for(int i=0;i<2;i++) {//三个for循环迭代实现矩阵快速幂
for(int j=0;j<2;j++) {
for(int k=0;k<2;k++) {
temp[i][j] = (temp[i][j]+(ans[i][k]*base[k][j])%1000000007)%1000000007;
}
}
}
return temp;
}
public static long fast_mod(long n ) {
long[][] base = {{1,1},{1,0}};
long[][] ans = {{1,0},{0,1}};//单位矩阵
while(n>0) {
if((n&1)==1) {//利用&与运算来加速判断
ans = multi(ans, base);
}
base = multi(base, base);
n >>= 1;//位运算
}
return ans[0][1];
}
}
Java的面向对象
什么是面向对象
面向对象编程的本质是：以类的方式组织代码，以对象的组织（封装）数据
封装
- 封装是面向对象的特征之一， 是对象和类概念的主要特性。封装是把过程和数据包围起来,对数据的访问只能通过指定的方式。
- 在定义一个对象的特性的时候，有必要决定这些特性的可见性，即哪些特性对外部是可见的，哪些特性用于表示内部状态。
- 通常，应禁止直接访问-一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。信息隐藏是用户对封装性的认识，封装则为信息隐藏提供支持。
public/private/protected的具体区别
- 1、public：public表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行调用
- 2、protected：protected对于子女、朋友来说，就是public的，可以自由使用，没有任何限制，而对于其他的外部class，protected就变成private。
- 3、private：private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用。
三种不同方式的继承，描述的是子类实例化对象对其成员的访问权限，并非是描述子类时，子类对继承自父类的成员的访问权限。
方法的重载
类中有多个方法,有着相同的方法名,但是方法的参数各不相同,这种情况被称为方法的重载。方法的重载可以提供方法调用的灵活性。
方法重载必须满足以下条件
- 方法名必须相同
- 参数列表必须不同(参数的类型、个数、顺序的不同)
public void test(Strig str){}
public void test(int a){}
public void test(Strig str,double d){}
public void test(Strig str){}
public void test(Strig str,double d){}
public void test(double d,Strig str){}
方法的返回值可以不同，也可以相同。
在java中,判断一个类中的俩个方法是否相同,主要参考俩个方面:方法名字和参数列表
继承
- 继承是一种联结类的层次模型，并且允许和支持类的重用，它提供了一种明确表述共性的方法。
- 新类继承了原始类后，新类就继承了原始类的特性，新类称为原始类的派生类(子类) ，而原始类称为新类的基类(父类) 。
- 派生类(子类)可以从它的基类(父类)那里继承方法和实例变量，并且派生类(子类)中可以修改或增加新的方法使之更适合特殊的需要继承性很好的解决了软件的可重用性问题。比如说，所有的Windows应用程序都有一一个窗口，它们可以看作都是从一个窗口类派生出来的。但是有的应用程序用于文字处理，有的应用程序用于绘图，这是由于派生出了不同的子类，各个子类添加了不同的特性。
Object类
Java Object 类是所有类的父类，也就是说 Java 的所有类都继承了 Object，子类可以使用 Object 的所有方法。
Object 类位于 java.lang 包中，编译时会自动导入，我们创建一个类时，如果没有明确继承一个父类，那么它就会自动继承 Object，成为 Object 的子类。
Object 类可以显示继承，也可以隐式继承，以下两种方式时一样的：显示继承:
public class Runoob extends Object{
}
隐式继承:
public class Runoob {
}
- Object类里面的方法
https://www.jb51.net/article/232849.htm
https://m.php.cn/article/462218.html
Super关键字
子类继承父类之后,在子类中可以使用this来表示访问或调用子类中的属性或方法,使用super就表示访问或调用父类中的属性和方法。
- 访问父类中的属性
public class Person{
protected String name = "zs";
}
public class Student extends Person{
private String name = "lisi";
public void tes(String name)t{
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
}
- 调用父类的方法
public class Person {
public void print() {
System.out.println("Person");
}
}
public class Student extends Person {
public void print() {
System.out.println("Student");
}
public void test() {
print();
this.print();
super.print();
}
}
this和super的区别
1.属性的区别：
this访问本类中的属性，如果本类没有此属性则从父类中继续查找。super访问父类中的属性。
2.方法的区别：
this访问本类中的方法，如果本类没有此方法则从父类中继续查找。super访问父类中的方法。
3.构造的区别：
this调用本类构造，必须放在构造方法的首行。super调用父类构造，必须放在子类构造方法首行。
4.其他区别：
this表示当前对象。super不能表示当前对象
- A、this. 变量和super.变量
- this.变量 调用的当前对象的变量；
- super.变量 直接调用的是父类中的变量。
- B、this(参数)和super(参数)方法
- this(参数) 调用（转发）的是当前类中的构造器；
- super(参数) 用于确认要使用父类中的哪一个构造器。
注意点：
- 1）在对拥有父类的子类进行初始化时，父类的构造方法也会执行，且优先于子类的构造函数执行；因为每一个子类的构造函数中的第一行都有一条默认的隐式语句super();
- 2）this() 和super()都只能写在构造函数的第一行；
- 3）this() 和super() 不能存在于同一个构造函数中。第一，this()和super()都必须写在构造函数的第一行；第二，this()语句调用的是当前类的另一个构造函数而这个另一个构造函数中必然有一个父类的构造器，再使用super()又调用一次父类的构造器， 就相当于调用了两次父类的构造器，编译器不会通过；
- 4）this和super不能用于static修饰的变量，方法，代码块；因为this和super都是指的是对象（实例）
多态
多态是指允许不同类的对象对于同一函数做出响应。
- 多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
一个父类引用可以指向它的任何一个子类对象
Object s3 = new Person();
Person s2 = new Student();
Student s1 = new Student();
子类继承父类,调用a方法，如果a方法在子类中没有重写,那么就是调用的是子类继承父类的a方法, 如果重写了,那么调用的就是重写之后的方法。
instanceof和类型转换
- instanceof：
instanceof是Java的一个保留关键字，先有继承关系，再有instanceof的使用左边是对象，右边是类，返回类型是Boolean类型。它的具体作用是测试左边的对象是否是右边类或者该类的子类创建的实例对象，是，则返回true，否则返回false。
System.out.println(a(对象） instanceof B （类）);
- 类型转换：
格式：((类型).对象).方法
子类转换为父类，可能会丢失一些原本的方法。
- instanceof （类型转换） 引用类型，判断一个对象是什么类型
高 --> 低 强制转换
低 --> 高 自动转换
新建一个Person父类
public class Person {
public void run (){
System.out.println("run121");
}}
新建一个student类
public class Student extends Person{
public void go(){
System.out.println("go123");
}}
新建一个主类：
public class Test {
public static void main(String[] args) {
// 高 低
Person x = new Student();
// student 将这个对象转换为Student类型，就可以使用Student类型的方法// x.go(); 此时的x不能调用子类的go方法；
((Student)x).go();
}}
输出：go123
注意：
- 父类引用可以指向子类对象，子类引用不能指向父类对象
修饰符
static
在类中,使用static修饰的成员方法，就是静态方法，反之为非静态方法。
在类中,使用static修饰的成员变量，就是静态变量，反之为非静态变量。
- 静态变量属于类的,"可以"使用类名来访问,非静态变量是属于对象的,"必须"使用对象来访问.
- 静态方法"不可以"直接访问类中的非静态变量和非静态方法,但是"可以"直接访问类中的静态变量和静态 方法
public class Student {
private static int count;
private int num;
public void run() {
}
public static void go() {
}
public static void test() {
//编译通过
System.out.println(count);
go();
//编译报错
System.out.println(num);
run();
}
}
final
1、修饰类
用final修饰的类不能被继承,没有子类。 例如:我们是无法写一个类去继承String类,然后对String类型扩展的,因为API中已经被String类定义为final 的了.
2、修饰方法
用final修饰的方法可以被继承,但是不能被子类的重写。 例如:每个类都是Object类的子类,继承了Object中的众多方法,在子类中可以重写toString方法、equals方 法等,但是不能重写getClass方法
wait方法等,因为这些方法都是使用fianl修饰的。 我们也可以定义final修饰的方法:
3、修饰变量
用final修饰的变量表示常量,只能被赋一次值.其实使用final修饰的变量也就成了常量了,因为值不会再变 了。
abstract
abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那 么该类就是抽象类。
1、抽象类和抽象方法的关系
抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
2、特点及作用
抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。 抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
注:子类继承抽象类后,需要实现抽象类中没有实现的抽象方法,否则这个子类也要声明为抽象类。
public abstract class Action{
public abstract void doSomething();
}
main:
//编译报错,抽象类不能new对象
Action a = new Action();
//子类继承抽象类
public class Eat extends Action{
//实现父类中没有实现的抽象方法
public void doSomething(){
//code
}
}
main:
Action a = new Eat();
a.doSomething();
接口
为什么要接口
接口就是比抽象类还抽象的抽象类，可以更加规范的对子类进行约束。全面地专业地实现了： 规范和具体实现的分离。
抽象类还提供某些具体实现，接口不提供任何实现，接口中所有方法都是抽象方法。接口是完全面 向规范的，规定了一批类具有的公共方法规范。
接口和类的区别
抽象类也是类,**除了可以写抽象方法以及不能直接new对象之外,其他的和普通类没有什么不一样的。**接口已经另一种类型了,和类是有本质的区别的,所以不能用类的标准去衡量接口。
声明类的关键字是class,声明接口的关键字是interface。
抽象类是用来被继承的,java中的类是单继承。
类A继承了抽象类B,那么类A的对象就属于B类型了,可以使用多态 一个父类的引用,可以指向这个父类的任意子类对象
注:继承的关键字是extends
接口是用来被类实现的,java中的接口可以被多实现。 类A实现接口B、C、D、E..,那么类A的对象就属于B、C、D、E等类型了,可以使用多态 一个接口的引用,可以指向这个接口的任意实现类对象
注:实现的关键字是implements
接口中的方法都是抽象方法
接口中可以不写任何方法,但如果写方法了,该方法必须是抽象方法
public interface Action{
public abstract void run();
//默认就是public abstract修饰的
void test();
public void go();
}
接口中的变量都是静态常量(public static final修饰)
接口中**可以不写任何属性,但如果写属性了,该属性必须是public static final修饰的静态常量。 **注:可以直接使用接口名访问其属性。因为是public static修饰的
注:声明的同时就必须赋值.(因为接口中不能编写静态代码块)
接口的作用
接口的最主要的作用是达到统一访问，就是在创建对象的时候用接口创建
【接口名】 【对象名】= new 【实现接口的类】
这样你像用哪个类的对象就可以new哪个对象了，不需要改原来的代码。
假如我们两个类中都有个function()的方法，如果我用接口，那样我new a()；就是用a的方法，new b（）就是用b的方法
这个就叫统一访问，因为你实现这个接口的类的方法名相同，但是实现内容不同
总结：
1、Java接口中的成员变量默认都是public,static,final类型的(都可省略),必须被显示初始化,即接口中的成员变量为常量(大写,单词之间用" _ "分隔)
2、Java接口中的方法默认都是public,abstract类型的(都可省略),没有方法体,不能被实例化
3、Java接口中只能包含public,static,final类型的成员变量和public,abstract类型的成员方法
4、接口中没有构造方法,不能被实例化
5、一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口
6、Java接口必须通过类来实现它的抽象方法
7、当类实现了某个Java接口时,它必须实现接口中的所有抽象方法,否则这个类必须声明为抽象
8、不允许创建接口的实例(实例化),但允许定义接口类型的引用变量,该引用变量引用实现了这 个接口的类的实例
9、 一个类只能继承一个直接的父类,但可以实现多个接口,间接的实现了多继承.
Comments | NOTHING