JA学习JAVA基础和知识点总结

JAVA如何安装jdk？

（JDK=jdk+jre）
1、下载对应于自己电脑配置的 jdk（如64位或者32位）；
2、点击安装
3、安装路径自己可以选择（如D：java\jdk）
4、安装完成以后进行配置jdk的运行环境变量
5、

6、

7、设置环境变量
变量名：JAVA_HOME
变量值：D:\Java\jdk // 要根据自己的实际路径配置
变量名：CLASSPATH
变量值：.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar; //记得前面有个"."
变量名：Path
变量值：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;

8、win+R 键输入cmd 回车进入命令控制符
9、运行java - version

10、运行javac 和 java 出现下列图片所示说明安装jdk成功

如何利用记事本创建java文件并运行java文件

1、打开记事本修改它的后缀名.txt为.java 即可创建java文件
2、win+r 输入cmd 打开命令控制符然后运行javac 文件名.java （进行编译文件）
3、.生成对应的文件名.class文件
4、然后java 文件名（就运行java文件了）
5、扩展：java编译package文件
如果java文件中使用的package表示java类的位置
在进行手动编译的时候，需要使用
Javac java源文件.java -d ./ (在当前位置) 进行java文件的编译操作。
-d 跟上我们自己定义的任何位置
编译之后会在java源文件同级目录位置，根据package的内容创建对应目录结构，java文件的编译后的字节码文件就会保存在创建目录中。
字节码文件生成之后，需要是java 包名+类的全路径进行执行。在执行的时候必须将目录处于包名的初级目录

DOS命名

```
   转盘符  例如：D：
```

   cd 进入文件或者退出文件 例如 cd aa/bb/cc   退出文件使用 cd ../  可以多层使用

  echo是向文件中写入内容的  例如： echo 哈哈哈>aa.txt  这是向aa.txt文档写入哈哈哈 并且>是覆盖之前的内容而>>是换行继续写入内容

 创建文件夹  md 文件夹名称 ---删除文件夹  rd 文件夹的名称

JAVA如何让别人也能看懂！！（JAVA标识符和命名规则）

标识符的合法定义：
1：由26个英文字母大小写，数字0-9，符号：_或$组成。
2：数字不可以开头。
3：不可以使用关键字和保留字，但能包含关键字与保留字。
4：Java严格区分大小写，长度无限制。
5：标识符不包含空格。

包名：多单词组成时所有的字母都小写。如：xxxyyyzzz
常量名：所有字母都大写，多单词组成时用下划线连接。XXX_YYY_ZZZ
类名接口名：多单词组成是所有的首字母大写。驼峰写法:XxxYyyZzz
变量名和函数名：多单词组成时，第一个单词首字母小写，之后的单词首字母大写。xxxYyyZzz

命名总结 ：数(数字和字符) 下(下划线）美人(美元符）数（数字不能开头）骆驼（驼峰写法）

数据类型

基本数据类型

引用数据类型

数值形

整数型-byte-short-int-long

浮点型-float-double

字符类-char

布尔类-boolean

数组

类-class

接口

整数型 byte 占1个字节 8位
整数型 short占2个字节 16位
整数型 int 占4个字节 32位
整数型 long 占8个字节64位
在这四种整数类型中，int类型是默认的整数型类型
浮点型 float 占4个字节 32位
浮点型 double占8个字节 64位
在这两种类型中默认都是double类型，（定义 float时候数值后面要加上F或者f）。
数据类型的大小顺序 byte -->short–>int–>long–>float–>double.

JAVA中的数据类型转换

1、数据类型的自动转换

数据类型范围小的可以自动向数据类型范围大的转换
当一个小的容器的水换到一个大的容器中毫无问题，但是一个大的容器的水换成小的容器则会装不下，就会溢出。
注意：char short char 是平级不能自动转换！！需要自己强制转换

2、数据类型的强制转换

例如：

double x = 3；
int sum ；
sum + = （int）x；

大的数据类型转换到小的数据类型需要进行强制转换
注意：强制转换时精度或者数据会丢失！！

JAVA中的常量与变量

1、常量

常量是代表程序运行过程中不能改变的值。
常量是用final修饰的一个量。
常量在程序运行过程中主要有2个作用：

代表常数，便于程序的修改（例如：final double PI = 3.14）。
增强程序的可读性。

2、变量

1、变量声明后没有赋值的话编译器会自动提示并赋予默认值。
2、变量是在一个栈内存中存储起来的名字，而它的数值是在一个堆内存中。
3、变量是可以改变的（相当于引用堆内存中不同的量）
4、变量的声明必须是变量类型和变量名称组成；（如：double salary；）

JAVA的运算符

1、算数运算符（+ - * / % ++ --）

++ 和- - 是自增和自减
例：

int sum = 5；
sum++;
system.out.println(sum);
运行结果：6

注意：++和 - - 如果在程序中的话 ++sum 和 sum++ 没有任何区别。
但是如果++和- - 在输出语句中的话，那么 ++sum是在输出前就先进行加运算
而sum++是在输出语句以后才进行加运算；

int sum = 5；
system.out.println(++sum);
运行结果：6

int sum = 5；
system.out.println(sum++);
运行结果：5

“/”这个是除法运算符号
“%”这个是取余运算符号（取剩下的余数）

2、赋值运算符（+ += -+ /= %= *=）

在JAVA中 “=” 是赋值运算符；右边的4 赋值给sum这个变量。

int sum；
sum = 4；
System.out.println(sum);
运行结果：4

赋值运算符中的 += 、 - =、 /= 、 %= 、*=；
等同于先进行加运算在进行赋值运算。。
例：

int sum = 2；
sum + = 2； //等价于 sum= sum + 2；
System.out,println(sum);
sum -= 1; //等价于 sum = sum - 1；
System.out,println(sum);运行结果：4
3

3、关系运算符（== != < > <= >= ）

关系运算符产生的结果必定为布尔类型。
例：`

if（1==1）{System.out,println("这是真的");
}else{System.out,println("这是假的");
}
运行结果：这是真的

4、逻辑运算符（&& || ！）

与运算符号（&&）

0	1	假
1	0	假
0	0	假
1	1	真

或运算符号（| |）

0	1	真
1	0	真
0	0	假
1	1	真

非运算符号（！）

真	假
假	真
0	1
1	0

口诀：与运算（一假则假）或运算（一真则真）

5、三元运算符

三元运算符
variable x = (expression) ? value if true : value if false ；
例：

int x = 5;
int y = (x>5)?4:3; //判断x是否>5 如果成立 就让Y= 4，否则就让Y＝3
System.out.println(y);
运行结果：3

三元运算符可以进行嵌套
例：

int y = 3;
String price = (y>3)? "西瓜":(y<3)?"苹果":"葡萄"；
System.out.println(price);
运行结果：葡萄

当进入三元运算符以后先进行判断–当再次遇到三元运算符的时候再次进行判断
知道判断到最后或者三元运算符结束时停止；

JAVA的流程控制

1、分支结构

1、if 语句

一个if语句包含一个布尔表达式和一条或多条语句。
if(布尔表达式){
//如果布尔表达式为true将执行的语句}
如果布尔表达式的值为true，则执行if语句中的代码块。否则执行If语句块后面的代码。
例：

int x = 3;
if(x>3){System.out.println("你明明大于3");
}
System.out.println("什么也没有发生");运行结果：什么也没有发生

2、if else 语句

if语句后面可以跟else语句，当if语句的布尔表达式值为false时，else语句块会被执行。
if…else的用法如下：
if(布尔表达式){ //如果布尔表达式的值为true}
else{ //如果布尔表达式的值为false}

int x = 3;
if(x>3){System.out.println("你明明大于3");
}else{System.out.println("我才不大于3");
}
System.out.println("什么也没有发生");运行结果：我才不大于3
什么也没有发生

3、if else if else 语句

if语句后面可以跟elseif…else语句，这种语句可以检测到多种可能的情况。
使用if，else if，else语句的时候，需要注意下面几点：
(1)、if语句至多有1个else语句，else语句在所有的elseif语句之后。
(2)、If语句可以有若干个elseif语句，它们必须在else语句之前。
(3)、一旦其中一个else if语句检测为true，其他的else if以及else语句都将跳过执行。

int x = 3;
if(x>3){System.out.println("你明明大于3");
}else if(<3){System.out.println("我才不大于3");
}else{System.out.println("我等于3");
}
运行结果：我等于3

2、switch语句

switch语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
(1)switch语句中的变量类型只能为byte、short、int或者char，JDK1.7版本及以上可以使用String。
(2)switch语句可以拥有多个case语句。每个case后面跟一个要比较的值和冒号。
(3)case语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
(4)当变量的值与case语句的值相等时，那么case语句之后的语句开始执行，直到break语句出现才会跳出switch语句。
(5)当遇到break语句时，switch语句终止。程序跳转到switch语句后面的语句执行。case语句不必须要包含break语句。如果没有break语句出现，程序会继续执行下一条case语句，直到出现break语句。
(6)switch语句可以包含一个default分支，该分支必须是switch语句的最后一个分支。default在没有case语句的值和变量值相等的时候执行。default分支不需要break语句。
例：

int x = 3;
switch（x）){case 1:System.out.println("写代码好累");
case 2::System.out.println("什么时候吃饭");
case 2::System.out.println("想玩游戏");
default:System.out.println("回家睡觉去");
}
运行结果：想玩游戏回家睡觉去

如果不加break; 那么当他执行完以后，它会自动执行以后的所有语句不管条件是否成立；
如上图JAVA代码

2、循环结构

循环结构的三要素：初始变量判断条件变量更新

1、while语句

while(判断条件){
代码块
变量更新语句
}

while语句会先判断括号中的条件是否成立或者为真，如果为真那么就执行java 代码块
同时变量更新一下直到while语句结束
如果变量没有更新的话就会陷入死循环
例

boolean bool = true；
while（bool）{System.out.println("一直循环");}
运行结果：
一直循环
一直循环
一直循环
.......

2、do while语句

do{
代码块
变量更新语句
}while（判断条件）；
do while 语句是先执行一遍在判断是否满足判断条件
所以 do while语句至少会更新一遍
例：

boolean bool = true；
do{System.out.println("至少运行一遍");
bool  = false；
}while（bool）
运行结果：
至少运行一遍

3、for 循环

for（初始变量；循环条件；变量更新）{
Java代码
}
for循环是专门针对数组采用的循环
(1)最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
(2)然后，检测布尔表达式的值。如果为true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
(3)执行一次循环后，更新循环控制变量。
(4)再次检测布尔表达式。循环执行上面的过程。
for ( ; ; ) 可以没有任何参数，代表是死循环
在for语句中可以同时声明多个变量，必须是同一类型的。

for（int i=0；i<2;i++）{system.out.println("第"+i"次");
}
运行结果： 第0次第1次

for循环的嵌套使用
~~外层循环循环一次内层循环循环一遍~~

public static void main(String[] args) {//外层循环   当条件满足的时候 循环一次for(int i=0;i<2;i++) {System.out.println("第"+i+"次开始报数");//循环学生进行报数1--13  进行条件判断 1--13for(int j=1;j<14;) {System.out.println("第"+j+"报数");if(j==10) {//                  break;
//                  return;continue;}j++;}//当内层循环一遍结束之 继续进行外层循环的判断}}

4、增强型for循环

for(声明语句 : 表达式){
//代码句子
}
1.声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
2.表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

int [] num = new in[5]；
for（int i：num）{system.out.println（i）；
}
运行结果 0 0 0 0 0

JAVA的 -break- - continue- -return- 关键字

1、break

break是结束当前循环

//输出1--10之间的所有数字,不输出7 之后的值for(int i=1;i<=3;i++) {System.out.print(i+"\t");if(i==2) {break;}System.out.print("我是break");}

break的加强版
定点跳出原来break只能结束当前所在循环，使用定点break，相当于给我们break添加一个跳出去的节点。
定位点必须在for循环语句的上面第一行

jieshu:
for(int i=1;i<3;i++) {System.out.println("第"+i);jieshu:for(int j=1;j<=3;j++) {System.out.println("我是第j"+j);for(int k=1;k<4;k++) {if(k==3) {break jieshu;}System.out.println("我是k"+k);}}}

2、continue

continue 是结束本次循环进入下一次循环开始

//输出1--10之间的所有数字,continuefor(int i=1;i<=3;i++) {System.out.print(i+"\t");if(i==2) {continue;}System.out.print("我是continue");}

3、return

return 结束当前所有循环

for(int i=1;i<3;i++) {System.out.println("第"+i);for(int j=1;j<=3;j++) {System.out.println("我是第j"+j);if(j==2){return;}}}}
运行结果：第1
我是第 j 1
我是第 j 2

Java 数组 ----保存多个相同数据类型的集合

1、数组的创建方式

第一种：数组类型 [] 数组的名字；

第二种  数组类型  数组的名字[]；

创建数组的规则说明有以下几点：
1．可以只给部分元素赋初值。
2．只能给元素逐个赋值，不能给数组整体赋值。
3．如不给可初始化的数组赋初值，则全部元素均为0值。（基本数据类型）
4．如给全部元素赋值，则在数组说明中，可以不给出数组元素的个数。

2、数组的使用

数组的使用规则：
1.既能存储原始数据类型，又能存储对象类型。
2.数组元素的个数称为数组的长度。长度一旦确定，就不能改变。
3.数组元素的下标是从0开始的，即第一个元素的下标是0。
4.可以创建数组的数组。
5.数组可以作为对象处理。数组对象含有成员变量length，用来表示数组的长度。

数组中元素的赋值和查看
在创建的时候只给定长度，不给具体的值。

```
num=new int[5];
```

在创建的时候给具体的值，不明确长度。

```
num=new int[]{1,5,8,25}
```

在使用时利用元素下标给数组赋值或查看

 num1[0]=10; num1[1]=20;system.out.println(num1[0]);system.out.println(num1[1]);运行结果 1020

利用for循环来查看值

 for(int i=0;i<num2.length;i++) {System.out.println(num2[i]);}

利用增强for循环来查看值

 for(int temp:num2) {System.out.println(temp);}

3、多维数组

多维数组就是一维数组中的元素是数组
多维数组中利用多重for循环来进行赋值或者查看值
注意: 多维数组中每个数组类型必须是相同的（数组中存储的是相同数据类型）

public static void main(String[] args) {//创建两个数组int [] num1=new int[3];int [] num2=new int[] {1,5,68,54,30,60};//创建多维数组int [][] num3=new int[2][];num3[0]=num1;num3[1]=num2;for(int i=0;i<=num3.length-1;i++) {for(int j=0;j<num3[i].length;j++) {System.out.println(num3[i][j]);}}运行结果：01 5 68 54 30 60

增强for循环
要注意的是利用增强for循环来输出多维数组的时候，
必须使用相对于的数组类型接收，接受几维数组就使用相对于少一维的几维数组接收。
//增强型for循环

     for(int[] temp:num3) {for(int temp1:temp) {System.out.println(temp1);}

面向对象编程

1、什么是类？什么是对象？

类：是具有相同属性和方法的多个对象的抽象。
属性是什么？
静态部分（描述）变量
方法是什么？
动态部分（行为）方法
对象：对象是通过new类得到，对象是具有自身属性和方法的类的一个具体的实例。
谁是个什么：谁就是对象，什么就是类。
注：先有类后有对象

简而言之：类中有属性和方法而对象是类的实例创建出来的。

2、如何创建类。

类名必须符合命名规则

class 类名{ }

一个.Java文件中只能有一个 public class 且这个类的名字必须和.java文件名保持一致

public class Lei{}

1、类里面如何创建属性和方法

构造方法

就是用来创建对象的时候用的。
语法： public 类名(【参数】){ java代码}
参数怎么写： 变量的类型名字

a. 有参数构造方法
是在new对象给对象赋值，给对象的属性赋值。如果类中没有属性就不能创建有参数构造方法，参数的个数可以是多个。不要超过属性的个数。
参数的名字可以与你要赋值的属性的名字一致，如果一致的话必须使用this关键字来进行参数和属性的区分。如果不用this就必须将参数的名字和属性的名不一样，但是参数的类型必须与要赋值的属性一致。
public 类名(【有参数】){ java代码}
```
public class Lei{String name；
public Lei（String name）{this.name = name;}}
```
b. 无参数构造方法创建对象的时候不赋值
public 类名(【无参数】){ java代码}
当类中没有任何构造方法的时候，会有一个默认的无参数构造方法，但是一旦类中有了有参数构造方法，就不会再有默认无参数构造方法。如果你在类中写了有参数构造方法，就一定要把无参数构造方法也显示的写出来。
```
public class Lei{public Lei（）{}}//如果不写有参构造方法 类中自带无参构造public class Lei{}
```
c. 构造方法的调用
在创建对象的时候根据有没有传参数来调用
new Person(); 根据你空号中是否传值，不传值代表调用的是无参数构造方法
如果传参数：根据参数的个数调用对应有参数构造方法，实际传的参数的类型必须与你要使用的有参数构造方法的参数类型以及类型的顺序一致
```
 class Lei{public Lei（）{}}public class Test{public static void main（String arg[]）{Lei lei = new Lei（）；}}
```

属性

属性就是变量 数据类型变量名
数据类型可以是基本数据类型，也可以是引用数据类型类（类类型）

属性分为全局属性和局部属性：
全局属性归当前类所有，他会有默认值，可以被当前所有非静态static方法调用。
局部属性归当前区域（方法）所有，局部变量在使用之前必须进行赋值，没有默认值。
当局部变量与全局变量名字相同时，采取局部优先原则。
静态属性可以被非静态方法和静态方法直接调用。非静态属性只能被非静态方法直接调用。

public class Lei{String name="李四"; //全局属性boolean bool = true；while（bool）{String name="张三"；//局部属性bool= false；System.out.println(name);
}System.out.println(name);
运行结果： 张三
李四

普通方法

方法是在类里面写的
【访问限定符】【修饰符】返回值类型方法名（【参数…】）{方法体 java代码}

访问限定符：限定方法的访问作用域 public

修饰符：static静态 final最终 abstract抽象

返回值类型：有返回值（可以是任何类型：基本、引用），如果方法有返回值name必须使用return关键字并且返回的内容必须与返回值类型一致无返回值void

参数：可以是任何类型可以是多个

方法分四类

无参数无返回值方法

public  void study() {System.out.println("我在学习java");}System.out.println();}}
//调用时 只会执行方法体中的Java代码

没返回值有参数

public void study(String name  ...) {System.out.println(this.name+"在学习");//在调用方法的时候，需要传入与形式参数类型一样的实际参数//形式参数可以有多个，如果形参是多个的话，实际参数的个数以及参数类型必须一致。}

有返回值没参数

public  String study1() {System.out.println("我在学习linux");return "hello";
}
}

有返回值有参数

public Student dedaoStu(Student stu) {Student stu = new Student();System.out.println(stu.name);return stu;// 在调用的时候需要传入对应的参数，使用return关键字。// 参数的类型可以是类类型。
}
}

1、Static 静态修饰符

被static修饰的属性和方法都属于类所有。在使用属性或者方法的时候可以直接是类名.方法名进行调用

1、代码块

{
代码块
}
代码块属于类所有，随着对象的创建被调用。每一次创建对象的时候都会被调用一次。

2、静态代码块

Static{
静态代码块
}
在程序启动类被加载到内存中的时候就会被调用，并且只调用一次

2、静态修饰符的使用

1) Static 数据类型属性名；

**非静态属性只能被非静态方法直接调用，
静态属性可以被静态或非静态方法直接调用。
静态属性属于类的，
非静态属性属于对象的。**

2) Public static 返回值类型方法名（【参数】）{}

静态方法归类所有，类名.方法名（【参数】）；
非静态方法归对象所有。对象名.方法名（【参数】）；
静态方法也可以被对象进行调用

注意：如果方法是非静态的，那么需要是用new对象利用对象.方法名
如果是静态方法，直接使用类名.方法名
属性也是如此。

例如

 package com.xingyun.static01;public class StaticShuXingDemo {//静态属性static String name;int age;static {name="张三";StaticShuXingDemo ssd= new StaticShuXingDemo();ssd.age=10;ssd.name="李四";System.out.println("静态代码块被调用");}//非静态方法public void getName() {System.out.println(name);//静态属性可以被静态和非静态方法直接调用System.out.println(age);}public static  int getAge() {System.out.println(age);//报错 静态不能调用非静态属性System.out.println(name);return 15;}public static void main(String[] args) {//调用静态方法StaticShuXingDemo.getAge();StaticShuXingDemo.getName();StaticShuXingDemo ssd=new StaticShuXingDemo();ssd.getName();String str="ascfdvfbgbdf";String str1=new String(str);System.out.println(str1.toUpperCase());

方法的重写和重载

1 方法重写
当发生继承关系时子类的方法和父类的方法方法名返回值参数列表相同（子类的修饰符必须大于等于父类）

2 方法重载
同一个类中方法名一样参数列表不一样返回值类型可以不一样

Java 封装继承多态抽象

首先先讲讲访问控制符：public private protected 默认

访问控制符	同一个类	不同类	不同包的子类	不同包的非子类
public	√	√	√	√
protected	√	√	√	×
默认	√	√	×	×
private	√	×	×	×

1 、封装

封装是对私有属性进行封装
我自己的东西不想让别人直接使用。但是可以使用方法来进行使用

a. 对私有化的属性进行封装
b. 封装就是使用方法来进行对属性的操作

一般封装的方法都称为get（）和set（）赋值，
每一个私有属性都对应的有一个get和一个set方法，方法的名是get或者set加上属性名字的首字母大写。

 Get 方法有返回值，且返回值的类型与属性的类型一致。 public  int getAge() {return age;}Set方法没有返回值 但是有参数，参数的类型必须与属性的类型一致。public void setAge(int age ) {this.age=age;}

当别的类调用的时候使用 set 来赋值使用get来获取值

2、继承

每个类都继承Object 类，Object属于所有类的父类
并且这种关系是系统默认的；

那么为了使两个类拥有关系，使用extends 关键字
Public class aa extends bb{}
aa与bb是子父类关系。 aa是子类 bb是父类。

继承的特点：
①　只能是单继承一个类中只能有一个直接父类。
②　一个类可以有多个子类。
③　子类继承了父类就拥有父类的所有属性和方法
④　子类可以有自己的独有的属性和方法。
⑤　可以在子类中写一个和父类一样的方法，方法的重写：在两个类中（子父类），方法的名字和参数以及参数的类型、顺序、个数都一样。方法的返回值也必须一致
⑥　如果A类继承了B类，B类继承了C 。那么A类也就拥有了C类的所有属性和方法。

This super 关键字
This代表当前对象
在使用方法的时候，一个类同时new出来多个实例对象，不同对象调用方法的时候，this代表不同的对象。
Super代表父类对象代表当前对象的父类

例如

public class a{
String name；
public a（）{
}
public a（String name）{
this.name = name;
}
}public class b{
a  aa = new a（"张三"）；
system.out.println("aa.name");运行结果；张三
}

3、多态

多态的体现：重写和重载

同一个对象拥有多种状态：
子类new 子类
父类new 父类
子类new 父类（向下转型）
父类new 子类（向上转型）

向上转型：子类转父类 Car cx = new JiaoCar();
编译时状态：子类=子类
运行时状态：子类=父类
将子类独有属性和方法进行隐藏

向下转型父类转子类 JiaoCar jc = (JiaoCar)cx;
必须是进行向上转型之后的那个父类对象，
进行强制转换赋值给子类对象。
转型之后就可以调用子类独有的属性和方法。

4、抽象

访问限定符 abstract class 类名{
方法：
普通方法 访问限定符返回值类型名字（【参数】）{}

抽象方法 访问限定符 abstract 返回值类型名字（【参数】）；

抽象类的特点：

1）所谓抽象方法，是指在类中仅仅声明了类的行为，并没有真正实现行为的代码。
2）抽象方法只能存在于抽象类中，正像刚才所言，一个类中只要有一个方法是抽象的，则这个类就是抽象的。类中只要有抽象方法，那么这个类必须被声明为抽象类
3）构造方法、静态（static）方法、最终（final）方法和私有（private）方法不能被声明为抽象的方法。构造方法不能是抽象的，抽象方法不能是私有的
4）一个抽象类中可以有一个或多个抽象方法，也可以没有抽象方法。
5）抽象类只能被继承（派生子类）而不能创建具体对象即不能被实例化。抽象类不能自己实例化自己
6）一个类如果继承了抽象类，那么就必须重写抽象中的所有抽象方法。重写抽象方法有具体的实现 Public abstract void
getAll();抽象方法 Public void getAll(){};重写的方法

学习JAVA的基础和知识点总结相关推荐

Java零基础学习Java编程语言基础知…
很多Java编程初学者在刚接触Java语言程序的时候,不知道该学习掌握哪些必要的基础知识.下面就说说Java零基础学习Java编程语言基础知识的几个要点.希望能够对Java编程基础入门学习的新手有帮助 ...
Java学习-Java语言基础
Java学习-Java语言基础 1.Java符号集 1.1Java标识符 1.2关键字 1.3分割符和注释 2.java 数据类型 2.1整型 2.1.1整型常量 2.1.2整型变量 ...
学习java的基础总结
java语言笔记(基础篇) 图片有点多,就没写 package 桌球01; import java.awt.Graphics; import java.awt.Image; import java.a ...
【JAVA】基础入门知识点回顾
1. public static String与 public static final String的差异 String 为不可变对象,一旦产生,就不可以改变其值. public static St ...
【超硬核】Java SE 基础语法知识点（C语言快速转Java）
目录 1.Java程序基础 1.1 JDK和JRD 1.2 命令行操作 1.3 pubilic+class 1.4 字节码文件 2.标识符 2.1 标识符的组成 2.2 遵守驼峰命名方式 2.3 类名 ...
Java开发基础面试知识点
目录 Java基础数据类型 ==和equals的区别 hashcode()和equals()方法 String.StringBuilder.StringBuffer区别访问权限修饰符 final修 ...
五、吃掉Java基本数据类型，学习Java的基础
@Author:Runsen @Date:2020/5/20 Java是一个强类型语言,Java中的数据必须明确数据类型.在Java中的数据类型包括基本数据类型和引用数据类型两种. 我是天天看菜鸟和W ...
【转】Java学习---Java Web基础面试题整理
[原文]https://www.toutiao.com/i6592359948632457731/ 1.什么是Servlet? 可以从两个方面去看Servlet: a.API:有一个接口servlet ...
零基础可以学习java吗_零基础真的可以学习java吗？
Java是一个比较抽象的开发语言,涉及知识点比较多,如果自学的话,可以按照五个阶段来学习,先学好基础知识,再逐步扩展,由易到难.要注意视频和书本内容相辅相成,切记不要只看视频而不忽略书本基础的知识要点 ...

学习JAVA的基础和知识点总结