Java特性和优势
- 简单性
- 面向对象
- 可移植性
- 高性能
- 分布式
- 动态性
- 多线程
- 安全性
- 健壮性
Java三大版本
- JavaSE:标准版(桌面程序,控制台开发…)
- JavaME:嵌入式开发(几乎已死)
- JavaEE:E企业级开发(web端,服务器开发…)
JDK、JRE、JVM
- JDK:Java Development Kit
- JRE:Java Runtime Environment
- JVM:JAVA Virtual Machine
JDK包括JRE、JVM,JRE包括JVM
JAVA关键字
abstract | asssert | boolean | break | byte |
case | catch | char | calss | const |
continue | default | do | double | else |
enum | extends | final | finally | float |
for | goto | if | implements | import |
instanceof | int | interface | long | native |
new | package | private | protected | public |
return | strictfp | short | static | super |
switch | synchronized | this | throw | throws |
transient | try | void | volatile | while |
- 所有的标识符都应该以字母(A-Z或者a-z),美元符号($)、或者下划线(_)开始
- 首字母之后可以是字母(A-Z或者a-z),美元符号($)、或者下划线(_)或数字的任何字符
- 不能使用关键字作为变量名或方法名
- 标识符是大小敏感的
- 合法的标识符举例:age、$salary、_value
数据类型
- 基本类型
byte | short | int | long | float | double | char | boolean |
---|---|---|---|---|---|---|---|
1个字节 | 2字节 | 4字节 | 8字节 | 4字节 | 8字节 | 2字节 | 1位 |
long类型要在数字后面加个L,float类型要在数字后面加个F
位(bit)是计算机内部数据储存的最小单位,11001100是一个八位二级制数
字节(byte):是计算机中数据处理的基本单位,习惯上用大写B来表示
1B(byte,字节) = 8bit(位)
字符:是指计算机中使用的字幕、数字、字和符号
- 引用类型
类 接口 数组 枚举 标注
*String是类,引用类型
- 类型转换
强制转换:(类型)变量名 高—>低
自动转换: 低—>高
1. 不能对布尔值进行转换
2. 不能把对象类型转换为不相干的类型
3. 在把高容量转换为低容量的时候,强制转换
- 转换的时候可能存在内存溢出,或者精度问题
变量
- 实例变量:从属于对象;如果不自行初始化,这个类型的默认值 0, 0.0
- 布尔值:默认是false
- 除了基本类型,其余的默认值都是null
类变量 static ,从属于类,会和类一起出来一起消失。
常量:final 常量名=值 (final double PI=3.14)
修饰符不存在先后顺序
变量名的命名规范
- 所有变量、方法、类名:见名知意
- 类成员变量:首字母小写和驼峰原则:monthSalary
- 局部变量:首字母小写和驼峰原则
- 常量:大写字母和下划线
- 类名:首字母大写和驼峰原则:Man , GoodMan
- 方法名:首字母小写和驼峰原则:run(),runRun()
位运算
A = 0011 1100
B = 0000 1101
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~B = 1111 0010
Scanner对象
基本语法:
package com.ljb;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// 创建一个扫描器对象,用于接收键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用next方式接收:");
//判断用户有没有输入字符串
if (scanner.hasNext()){
//使用next方式接收
String str = scanner.next();
System.out.println("输入内容为:"+ str);
}
//凡是属于IO流的类如果不关闭会一直占用资源,要养成好习惯用完就关掉
scanner.close();
}
}
输出结果:
使用next方式接收:
Hello world
输入内容为:Hello
-------------------------------------------------------------------------
package com.ljb;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// 创建一个扫描器对象,用于接收键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用next方式接收:");
//判断用户有没有输入字符串
if (scanner.hasNextLine()){
//使用next方式接收S
String str = scanner.nextLine();
System.out.println("输入内容为:"+ str);
}
//凡是属于IO流的类如果不关闭会一直占用资源,要养成好习惯用完就关掉
scanner.close();
}
}
输出结果:
使用nextLine方式接收:
hello world
输入内容为:hello world
- next():
- 一定要读取到有效字符后才可以结束输入。
- 对输入有效字符之前遇到的空白,next()方法会自动将其去掉。
- 只有输入有效字符后才将其后面输入空白作为分隔符或者结束符。
- next()不能得到带有空格的字符串
- nextLine():
- 以Enter为结束符,也就是说nextLine()方法返回的是输入回车之前的所有字符。
- 可以获得空白。
println 输出完会换行
print 输出完不会换行。
break 在任何循环语句的主体部分,均可用break控制循环流程。break用于强行退出循环,不执行循环中剩余的语句。
continue 语句用在循环语句体中,用于终止某次循环过程,即跳过循环体中尚未执行的语句,接着进行下一次是否执行循环的判定。
打印三角形
package com.ljb;
public class test1 {
public static void main(String[] args) {
//打印三角形
for (int i = 0; i <= 5; i++) {
for (int j = 5; j >= i; j--) {
System.out.print(" ");
}
for (int j = 1; j <= i; j++){
System.out.print("*");
}
for(int j = 1; j < i; j++){
System.out.print("*");
}
System.out.println();
}
}
}
九九乘法表
package com.ljb;
public class addTet {
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i < 10; i++) {
for (int i1 = 1; i1 <= i; i1++) {
sum = i * i1;
System.out.print(i1 + "*" + i + "=" + sum+ "\t");
}
System.out.println();
}
}
}
方法重载
- 重载就是在一个类中,有相同的函数名称,但形参不同的函数。
- 方法的重载的规则
- 方法名称必须相同
- 参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等)。
- 方法的返回类型可以相同也可以不相同
- 仅仅返回类型不同不足以成为方法的重载。
- 参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等)。
- 方法名称必须相同
- 实现理论
- 方法名称相同是,编译器会根据调用方法的参数个数、参数类型等去逐个匹配,以选择对应的方法,如果匹配失败,则编译器报错。
递归
- 递归就是A方法调用A方法,就是自己调用自己。
-
- 递归头:什么时候不调用自身方法。如果没有头,将陷入死循环。
- 递归体:什么时候需要调用自身方法。
package com.ljb;
public class test2 {
public static void main(String[] args) {
System.out.println(f(3));
}
//阶乘方法
public static int f(int n){
if (n==1){
return 1;
}else {
return n*f(n-1);
}
}
}
数组
-
首先必须声明数组变量,才能在程序中使用数组。下面是声明数组变量的方法:
-
dataType[] arrayRefVar; //首选方法 dataType arrayRefVar[]; //效果相同,但不是首选方法
-
Java语言使用new操作符来创建数组,语法如下:
-
dataType[] arrayRefVar = new dataType[arraySize]; //类似 dataType[] arrayRefVar; //1.声明一个数组 arrayRefVar = new dataType[arraySize]; //创建一个数组 arrayRefVar[0] = 1; //赋值
-
数组的元素是通过索引访问的,数组索引从0开始。
-
获取数组长度:
arrays.length
三种初始化
-
静态初始化(创建 + 赋值)
-
int[] a = { 1,3,4}; //不可改变了 Man[] mans = { new Man(1,1), new Man(2,2)};
-
动态初始化(包含默认初始化)
-
int[] a = new int[2]; a[0] = 1; a[1] = 2;
多维素组
-
二维数组:
-
int a[][] = new int[2][5]
-
int[][] array = { { 2,3},{ 2,2},{ 123,213}}
稀疏数组
package com.ljb;
public class test3 {
public static void main(String[] args) {
//1.创建一个二维数组11*11 0:没有棋子 1:黑棋 2:白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
//输出原始的数组
System.out.println("输出原始数组");
for (int[] ints : array1) {
for (int anInt : ints) {
System.out.print(anInt + "\t");
}
System.out.println();
}
System.out.println("-------------------------------");
//转换为稀疏数组保存
//获取有效值的个数
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (array1[i][j] != 0){
sum++;
}
}
}
System.out.println("有效值的个数:" +sum);
//1.创建一个稀疏数组的数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//遍历二维数组,将非零的值,存在稀疏数组中
int count = 0;
for (int i = 0 ; i <array1.length; i++){
for (int j = 0; j < array1[i].length; j++) {
if (array1[i][j] != 0){
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
}
}
}
//输出稀疏数组
System.out.println("稀疏数组");
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i][0] + "\t"
+ array2[i][1] + "\t"
+ array2[i][2] + "\t");
}
System.out.println("-------------------------------");
System.out.println("还原");
//1.读取稀疏数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//2.给其中的元素还原它的值
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
//输出还原的数组
System.out.println("输出还原数组");
for (int[] ints : array3) {
for (int anInt : ints) {
System.out.print(anInt + "\t");
}
System.out.println();
}
}
}
面向对象(OOP)
-
面向对象思想:物语类聚,分类的思维模式,思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后,才对某个分类下的细节进行面向过程的思索。
-
面向对象编程的本质:以类的方式组织代码,以对象的组织(封装)数据。
-
三大特性:封装、继承、多态
对象:具体的事物 类:是抽象的,是对对象的抽象
类与对象的关系
- 类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物。
- 动物、植物、手机、电脑…
- Person类、Pet类、Cat类等,这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
- 对象是抽象概念的具体实例。
- 张三就是人的一个具体实例,张三加的里的旺财就是狗的一个具体实例。
- 能够体现出特点,展示出功能的是具体的实例,而不是一个抽象的概念。
类是对象的一个抽象,而对象是类的一个具体实例化
类是抽象的,类实例化后悔返回一个自己的对象
构造器
- 类中的构造器也称为构造方法,是在进行创建杜旭的时候必须要调用的。并且构造器有以下两个特点:
- 1.必须和类的名字相同
- 2.必须没有返回类型,也不能写void
自动生成构造器快捷键:alt+ insert
package com.ljb;
public class test4 {
public static void main(String[] args) {
Person person = new Person("lujiebin",18);
System.out.println(person.name + "\n" + person.age);
}
}
package com.ljb;
public class Person {
//一个类即使什么都不写,它也会存在一个方法
//显示定义的构造器
String name;
int age;
//构造器作用:1.使用new关键字,必须要有构造器 2.用来初始化值
//无参构造
public Person(){
}
//有参构造:一旦定义了有参构造,无参构造就必须显示定义
public Person(String name){
this.name = name;
}
public Person(String name, int age){
this.name = name;
this.age =age;
}
}
封装
-
“高内聚,低耦合”;属性私有,get/set
-
package com.ljb; public class test5 { public static void main(String[] args) { Student s1 = new Student(); s1.setName("lujiebin"); System.out.println(s1.getName()); s1.setAge(999); System.out.println(s1.getAge()); } }
-
package com.ljb; public class Student { private String name; //名字 private int id; //学号 private char sex; //性别 private int age; //年龄 //提供一些可以操作这些属性的方法,提供一些public的get、set 方法 //get 获得这个数据 public String getName(){ return this.name; } //set 给这个数据设置值 public void setName(String name){ this.name = name; } public int getAge() { return age; } public void setAge(int age) { if (age > 120 || age < 0) { System.out.println("年龄不合法"); } else { this.age = age; } } }
-
提高程序的安全性,保护数据
-
隐藏代码的实现细节
-
统一接口
-
系统可维护性增加了
继承
-
继承的本质是都某一批类的抽象,从而实现世界更好的建模
-
extands的意思是“扩展”。子类是父类的扩展。
-
Java中类只有单继承,没有多继承!
-
继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
-
继承关系的两个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
-
子类和父类之间,从意义上讲应该具有“is a” 的关系。
-
私有private的无法继承。
-
package com.ljb.demo; public class demo { public static void main(String[] args) { Student student = new Student(); student.say(); System.out.println(student.money); } }
-
package com.ljb.demo; //父类 public class Person { public int money = 100_0000; public void say(){ System.out.println("说了一句话"); } }
-
package com.ljb.demo; //学生 is 人 //子类继承了父类,就会拥有父类的全部方法 public class Student extends Person{ }
super
- super调用父类的构造方法,必须在构造方法的第一个-
- super 必须只能出现在子类的方法或者构造方法中!
- super和this不能同时调用构造方法
和this相比较:
- 代表的对象不同
- this: 本身调用者这个对象
- super: 代表父类对象的应用
- 前提
- this: 没有继承也可以使用
- super: 只能在继承条件下可以使用
- 构造方法
- this(): 本类的构造
- super():父类的构造!
方法重写
- 重写都是方法的重写
- 需要有继承关系,子类重写父类的方法
- 方法名必须相同
- 参数列表必须相同
- 修饰符:范围可以扩大 : public>protected>default>private
- 抛出异常:范围,可以被缩小,但不能扩大。
- 子类的方法和父类的方法必须保持一致,方法体不同
- 子类重写了父类的方法,执行子类的方法
为什么要重写:
- 父类功能,子类不一定需要,或者不一定满足!
多态
- 即同一方法可以根据发送对象的不同采用多种方式的行为方式。
- 一个对象的实际类型是确定的,但可以指向对象的引用的类型有很多
- 多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
- 注意:多态是方法的多态,属性没有多态性。
类型转换
- 父类引用指向子类的对象
- 把子类转换为父类,向上转型
- 把父类转换为子类,向下转型;需要强制转换,
- 方便方法的调用,减少重复的代码。
Static
static和类一起加载
package com.ljb.demo; public class Student{ private static int age; //静态的变量 private double score; //非静态的变量 public void run(){ } public static void go(){ } public static void main(String[] args) { Student s1 = new Student(); System.out.println(Student.age); System.out.println(s1.age); System.out.println(s1.score); Student.go(); } }
接口
-
普通类:只有具体实现
-
抽象类:具体实现和规范(抽象方法)都有!
-
接口:只有规范
-
接口就是规范,定义的是一组规则,体现了现实世界中“如果你是…则必须…”的思想。如果你是天使,则必须能飞。如果你是汽车,则必须能跑。如果你是好人,则必须干掉坏人;如果你是坏人,则必须欺负好人
-
接口的本质是契约,就像我们人间的法律一样。制定好后大家都遵守
-
OOD的精髓,是对对象的抽象,最能体现这一点的就是接口。为什么我们讨论设计模式都值针对具备了抽象能里的语言(比如c++、java等),就是因为设计模式所研究的,实际上就是如何合理去抽象。
内部类
-
内部类就是在一个类的内部再定义一个类,比如,A类中定义一个B类,那么B类相对A类来说就称为内部类,而A类相对B类来说就是外部类了
-
- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类
-
package com.ljb.demo; public class demo1 { public static void main(String[] args) { Outer outer = new Outer(); //通过这个外部类来实例化内部类 Outer.Inner inner = outer.new Inner(); inner.getID(); } }
-
package com.ljb.demo; public class Outer { private int id = 10; public void out(){ System.out.println("这是外部类的方法"); } public class Inner{ public void in(){ System.out.println("这是内部类的方法"); } //获得外部类的私有属性 public void getID(){ System.out.println(id); } } }
异常机制
快捷键:ctrl+alt+t
package com.ljb.demo; public class demo2 { public static void main(String[] args) { int a = 1; int b = 0; try{ //try监控区域 System.out.println(a/b); }catch (ArithmeticException e){ //catch 捕获异常 System.out.println("程序出现异常,变量b不能为0"); }finally { //处理善后工作 System.out.println("finally"); } } } //finally 可以不要finally,假设IO,资源,关闭!