JDK包括JRE、JVM,JRE包括JVM
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 |
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. 在把高容量转换为低容量的时候,强制转换
- 转换的时候可能存在内存溢出,或者精度问题
类变量 static ,从属于类,会和类一起出来一起消失。
常量:final 常量名=值 (final double PI=3.14)
修饰符不存在先后顺序
A = 0011 1100
B = 0000 1101
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~B = 1111 0010
基本语法:
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
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();
}
}
}
- 重载就是在一个类中,有相同的函数名称,但形参不同的函数。
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();
}
}
}
面向对象思想:物语类聚,分类的思维模式,思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后,才对某个分类下的细节进行面向过程的思索。
面向对象编程的本质:以类的方式组织代码,以对象的组织(封装)数据。
三大特性:封装、继承、多态
对象:具体的事物 类:是抽象的,是对对象的抽象
类是对象的一个抽象,而对象是类的一个具体实例化
类是抽象的,类实例化后悔返回一个自己的对象
自动生成构造器快捷键: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{
}
和this相比较:
为什么要重写:
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,资源,关闭!