参照视频[狂神说java]([狂神说Java]Java零基础学习视频通俗易懂_哔哩哔哩 (゜-゜)つロ 干杯~-bilibili)
标识符注意点
- 不能使用关键字作为变量名
- 标识符对大小写敏感
public class Demo02 {
public static void main(String[] args) {
String a = "hello";
int num = 10;
long num4 = 30L;//Long类型要在数字后面加个L
//小数：浮点数
float num5 = 50.1F;
double num6 = 3.1415926;
//字符
char name = 'Q';
//字符串，String不是关键字，类
String namea ="秦将";
//布尔值
boolean num7 = false;
System.out.println(a);
}
}
数据类型
-
Java是强类型语言
Java的数据类型
- 基本类型(primitive type) 整数类型、浮点类型、字符类型char（占2个字节）、boolen类型。short 2字节
- 引用类型(reference type)：类、接口、数组
public class Demo3 { public static void main(String[] args) { //整数拓展： 进制 二进制0b 八进制0 十六进制0x int i = 10; int i2 = 010;//八进制 int i3 = 0x10;//十六进制0x 0~9 A~F System.out.println(i); System.out.println(i2); System.out.println(i3); System.out.println("=========="); //================================================= //浮点数拓展？ 银行业务怎么表示？ 钱 //BigDecimal 数学工具类 //float 有限 离散 舍入误差 大约 接近但不等于 //double //最好完全不用浮点数进行比较 float f =0.1f; double d = 1.0/10; System.out.println(f==d); float d1 = 231231231231231231232131f; float d2 = d1 + 1; System.out.println(d1==d2); char c1 = 'a'; char c2 = '中'; System.out.println(c1); System.out.println((int)c1); System.out.println(c2); System.out.println((int)c2); //所有的字符本质还是数字 //编码 Unicode 表：(97 = a 65 =A) 2字节 0 - 65535 Excel 2 16 = 65536 //U0000 UFFFF char c3 = '\u0061'; System.out.println(c3); //a //转义字符 //\t 制表符 //\n 换行 System.out.println("Hello\tWorld"); System.out.println("Hello\nWorld"); System.out.println("======================================"); String sa = new String("hello world"); String sb = new String( "hello world"); System.out.println(sa==sb); String sc = "hello world"; String sd = "hello world"; System.out.println(sc==sd); //对象 从内存分析 //布尔值扩展 boolean flag = true; if(flag==true) { } } }类型转换
- 低--------------------------------------->高
- byte,short,char-> int -> long-> float -> double
public class Demo5 {
public static void main(String[] args) {
int i = 128;
byte b = (byte)i; //溢出
//强制转换 （类型）变量名 高--低
//自动转换 低--高
System.out.println(i);
System.out.println(b);
/*
注意点：
1.不能对布尔值进行转换
2.不能把对象类型转换为不相干类型
3.精度问题
4.高--低
*/
System.out.println("=================");
System.out.println((int)23.7);
System.out.println((int)-45.89f);
System.out.println("=========");
//JDK7新特性，数字之间可以用下划线分割
int money = 10_0000_0000;
int years = 20;
int total = money*years;
long total2 = money*years;
long total3 = money*((long)years);
System.out.println(total3);
}
}
变量
- 类变量
- 实例变量
- 局部变量
public class Demo08 {
//类变量 static
static double salary = 2500;
//属性：变量
//实例变量：从属于对象;如果不进行初始化，这个类型的默认值 0 0.0
//布尔值：默认是false
//除了基本类型，其余的默认值都是null；
String name;
int age;
//main 方法
public static void main(String[] args) {
//局部变量；必须声明和初始化
int i = 10;
System.out.println(i);
//变量类型 变量名字 = new Demo08();
Demo08 demo08 = new Demo08();
System.out.println(demo08.age);
System.out.println(demo08.name);
//类变量 static
System.out.println(salary);
}
}
常量
- final 变量
变量的命名规范
- 所有变量、方法、类名：见名知意;
- 类成员变量：首字母小写和驼峰原则：monthSalary;
- 局部变量：首字母小写和驼峰原则；
- 常量：大写字母和下划线：MAX_VALUE;
- 类名：首字母大写和驼峰原则：Man,GoodMan;
- 方法名：首字母小写和驼峰原则：run(),runRun();
运算符
package operator;
public class Demo03 {
public static void main(String[] args) {
//幂运算 2^3 2*2*2 = 8
double pow = Math.pow(2,3);
System.out.println(pow);
}
}
package operator;
public class Demo03 {
public static void main(String[] args) {
//幂运算 2^3 2*2*2 = 8
double pow = Math.pow(2,3);
System.out.println(pow);
//与 或 非
boolean a =true;
boolean b =false;
System.out.println("a && b: "+(a&&b));
System.out.println("a || b:"+(a||b));
System.out.println("!(a&&b):"+!(a&&b));
//短路运算
int c =5;
boolean d = (c<4)&&(c++<4);
System.out.println(d);
System.out.println(c);
//三元运算符
int a1 = 10;
int b1 = 20;
a1+=b1; //a = a+b
a1-=b1; //a = a-b
System.out.println(a1);
//字符串连接符 + ，String
System.out.println(""+a1+b1);
System.out.println(a1+b1+"");
System.out.println(""+(a1+b1));
//三目运算
//x ? y : z
int score = 80;
String type = score <60 ?"不及格":"及格";
System.out.println(type);
}
}
包机制
-
包的本质是文件夹，一般利用公司域名倒置作为包名com.kuangstudy.blog
-
为了能够使用某一包的成员，需要在Java程序中明确导入该包。使用"import"语句可完成此功能。
package com.kuang.operator; import java.util.Date; import com.kuang.base.*;package放在import前面
JavaDoc
Java流程控制
用户交互scanner
Scanner s = new Scanner(System.in);
package com.kuang.scanner;
import java.util.Scanner;
public class Demo01 {
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();
}
}
package com.kuang.scanner;
import java.util.Scanner;
public class Demo02 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("使用nextLine方式接收： ");
//判断用户有没有输入字符串
if(scanner.hasNextLine())
{
//使用next方式接收
String str = scanner.nextLine();
System.out.println("输出的内容为： "+str);
}
//凡属IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
scanner.close();
}
}
package com.kuang.scanner;
import java.util.Scanner;
public class Demo05 {
public static void main(String[] args) {
//输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果
Scanner scanner = new Scanner(System.in);
//和
double sum = 0;
int m =0;
while(scanner.hasNextDouble())
{
double x = scanner.nextDouble();
m++;
sum = sum +x;
}
System.out.println(m+ "个数的和为"+sum);
scanner.close();
}
}
- switch语句中的变量类型可以是：byte、short、int、char。
- 从Java SE 7开始 switch支持String类型
for(初始化; 布尔表达式;更新)
九九乘法表
package com.kuang.scanner;
public class Demo06 {
public static void main(String[] args) {
for (int j = 1; j <= 9; j++) {
for (int i = 1; i <= j; i++) {
System.out.print(i+"*"+j+"="+(j*i)+"\t");
}
System.out.println();
}
}
}
增强型for循环
-
java5引入
-
for(声明语句:表达式) { }
package com.kuang.scanner;
public class Demo06 {
public static void main(String[] args) {
int[] numbers = {10,20,30,40,50};
//遍历数组的元素
for(int x:numbers)
{
System.out.println(x);
}
}
}
方法
-
一个方法只完成1个功能，有利于后期的扩展。
-
方法的定义
修饰符 返回值 方法名(参数类型 参数) { ... 方法体 ... return 返回值; } -
方法的重载
-
方法名称相同
-
方法的参数必须有不同
-
返回类型不足以作为重载的区分
-
-
命令行传参
- 程序运行时传递参数，
package method;
public class Demo02 {
public static void main(String[] args) {
//args.length 数组长度
for(int i =0;i<args.length;i++)
{
System.out.println("args["+i+"]:"+args[i]);
}
}
}
-
可变参数
JDK 1.5开始
- 在方法声明中，在指定参数类型后加一个省略号
- 一个方法只能指定一个可变参数，它必须是方法的最后一个参数。
package method; public class Demo03 { public static void main(String[] args) { Demo03 demo03 = new Demo03(); demo03.test(1,2,3,4,5,6,7,8,1,1,1,1,1,1,1,1,1,1,1,1); printMax(34,3,3,5,56.6); printMax(new double[]{1,2,3}); } public void test(int x,int... i) { System.out.println(i[10]); } public static void printMax(double... numbers){ if(numbers.length==0){ System.out.println("No argument passed"); return; } double result = numbers[0]; // for(int i = 1;i< numbers.length;i++){ if(numbers[i] > result){ result = numbers[i]; } } System.out.println("The max value is "+ result); } } -
递归
数组
-
数组定义
package method; public class ArrayDemo01 { public static void main(String[] args) { int[] nums;//声明一个数组 nums = new int[10];// 创建一个数组 for(int i = 0;i<nums.length;i++) { nums[i] = i+1; } } } -
内存分析
- 声明数组 int[] array = null; 在栈中有一个名字 int array[] = null;
- 创建数组 array = new int[10];在堆中开辟区间
-
数组的特点
- 数组一旦被创建，其大小不可改变
- Java中对象是在堆中的，数组可以看成是对象
- ArrayIndexOutOfBoundsException, 数组下标越界
-
数组的使用
-
package method; public class ArrayDemo02 { public static void main(String[] args) { int[] arrays = {1,2,3,4,5}; int sum = 0; for(int i = 0;i < arrays.length;i++) { sum = sum + arrays[i]; } System.out.println("sum:"+sum); for(int array:arrays) { System.out.println(array); } int[] reverse = reverse(arrays); printArray(reverse); } //反转数组 public static int[] reverse(int[] arrays){ int result[] = new int[arrays.length]; for(int i = 0;i<arrays.length;i++){ result[i] = arrays[arrays.length-1-i]; } return result; } //打印数组 public static void printArray(int[] arrays){ for(int i = 0; i < arrays.length; i++) { System.out.print("arrys["+i+"]:"+arrays[i]+"\t"); } System.out.println(); } }int[][] array = {{1,2},{2,3},{3,4},{4,5}}; for(int i = 0; i<array.length;i++){ for(int j = 0; j<array[i].length;j++) { System.out.println(array[i][j]); } }
-
-
Arrays具有常用功能：给数组赋值通过fill，对数组排序通过sort，比较数组通过equals方法比较数组中元素是否相等，查找数组元素通过binarySearch方法对排序好的数组进行二分查找法操作。
-
int[] a = {1,2,3,4,6,454,234}; System.out.println(Arrays.toString(a)); //输出 [1, 2, 3, 4, 6, 454, 234] Arrays.sort(a); System.out.println(Arrays.toString(a));
-
-
稀疏数组
面向对象编程
-
以类的方式组织代码，以对象的组织（封装）数据
-
三大特性：封装、继承、多态
-
String在Java中属于类，不是关键字
-
构造方法必须与类名相同，必须没有返回值
package oop; //学生类 public class Student { //属性：字段 String name; int age; //1.使用new关键字，本质是在调用构造器 public Student() { this.name = "xingk"; } //一旦定义有参构造，无参构造器必须显示定义 public Student(String name) { this.name = name; } //方法 public void study(){ System.out.println("在学习"); } } -
封装：高内聚，低耦合。属性私有get,set。
package oop; //学生类 public class Student { //属性：字段 private String name; private int age; //1.使用new关键字，本质是在调用构造器 public Student() { this.name = "xingk"; } //一旦定义有参构造，无参构造器必须显示定义 public Student(String name) { this.name = name; } //方法 public void study(){ System.out.println("在学习"); } public String getName(){ return this.name; } public void setName(String name){ this.name = name; } } -
继承：Java中类只有单继承，没有多继承。
- Java中类都继承了object类
-
super注意点：
-
super调用父类的构造方法，必须在构造方法的第一个
-
super必须只能出现在子类的方法或者构造方法中
-
super和this不能同时调用构造方法
-
this();本类的构造
-
super();父类的构造
package method; //基类 public class Person{ protected String name = "kuangshen"; } ====================================================== package oop; import method.Person; //学生类,派生类 public class Student extends Person { private String name = "qinjiang"; public void print(){ System.out.println(this.name); System.out.println(super.name); } } ============================================================= package oop; public class Application { public static void main(String[] args) { /* 3.对应的引用 引用类型： 基本类型(8) 对象是通过引用来调用的栈---->堆 4.属性：字段Filed 成员变量 默认初始化： 数字： 0 0.0 char: u0000 boolean: false 引用: null */ Student xiaoming = new Student(); xiaoming.print(); } } ==================== 输出 qinjiang kuangshen
-
-
方法重写需要有继承关系，子类重写父类的方法
-
方法名必须相同
-
参数列表列表必须相同
-
修饰符：范围可以扩大但不能缩小：public>protected>default>private
-
抛出的异常：范围可以被缩小，但不能扩大；ClassNotFoundException–>Exception（大）
-
Alt+Insert: override
package method; //基类 public class Person{ protected String name = "kuangshen"; public void test() { System.out.println("Person=>test()"); } public static void test1() { System.out.println("Person=>test1()"); } } ======================================================= package oop; import method.Person; //学生类,派生类 public class Student extends Person { private String name = "qinjiang"; public void print(){ System.out.println(this.name); System.out.println(super.name); } public void test() { System.out.println("Student=>test()"); } public static void test1() { System.out.println("Student=>test1()"); } } ============================================================ package oop; import method.Person; public class Application { public static void main(String[] args) { /* 3.对应的引用 引用类型： 基本类型(8) 对象是通过引用来调用的栈---->堆 4.属性：字段Filed 成员变量 默认初始化： 数字： 0 0.0 char: u0000 boolean: false 引用: null */ //静态方法是类的方法，非静态方法是对象的方法 ，new创建对象 Student A = new Student(); Person B = new Student(); A.test(); B.test(); A.test1(); B.test1(); } } ======================================================== 输出 Student=>test() Student=>test() Student=>test1() Person=>test1()
-
-
多态
-
instanceof 判断对象是否是类的实例
package oop; import method.Person; public class Application { public static void main(String[] args) { Person s1 = new Student(); System.out.println(s1 instanceof Student); ((Student)s1).print(); } } -
static关键字，final修饰的类不能被继承了。
package method; //静态导入包 import static java.lang.Math.random; public class Student1 { private static int age;//静态的变量 多线程！ private double score; //非静态的变量 { System.out.println("匿名代码块"); } static{ //只运行一次 System.out.println("静态代码块"); } public Student1(){ System.out.println("构造方法"); } public static void main(String[] args) { Student1 person = new Student1(); Student1 person1 = new Student1(); System.out.println(random()); } } ======================================================== 输出 静态代码块 匿名代码块 构造方法 匿名代码块 构造方法 0.8565026626018188 -
抽象类，abstract修饰符
package oop; //abstract 抽象类 public abstract class Demo02 { //约束，继承子类实现 //abstract ,抽象方法，只有方法名字，没有方法的实现！ public abstract void doSomething(); //1.不能new这个抽象类，只能靠子类去实现它；约束！ //抽象类可以写普通的方法 //抽象方法必须在抽象类中 } -
接口
-
普通类具体实现
-
具体实现和规范（抽象方法）都有！
-
接口：只有规范！自己无法写方法~专业的约束！约束和实现分离：面向接口编程
-
关键字 interface
-
作用：1.约束，2，定义一些方法，让不同的人实现，3.public abstract 4.public static final, 5. 接口不可以被实例化，接口中没有构造方法
-
implements 可以实现多个接口
-
必须重写接口中的方法
package oop; //interface 定义的关键字，接口都需要实现 public interface UserService{ //接口中的所有定义其实都是抽象的public abstract //常量 public static final int AGE = 99; void add(String name); void delete(String name); void update(String name); void query(String name); } ================================================= package oop; public class UserServiceImp1 implements UserService,TimeService { @Override public void add(String name) { } @Override public void delete(String name) { } @Override public void update(String name) { } @Override public void query(String name) { } } =============================================== package oop; public interface TimeService { }
-
-
-
内部类
package oop; 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); } } } =============================================================== package oop; import method.Person; public class Application { public static void main(String[] args) { Outer outer = new Outer(); //通过这个外部类来实例化内部类 Outer.Inner inner = outer.new Inner(); inner.in(); inner.getID(); } } ==================================================== package oop; public class Test { public static void main(String[] args) { //没有名字初始化类，不用将实例保持到变量中 new Apple().eat(); UserService1 userService = new UserService1() { @Override public void hello() { } } } } class Apple{ public void eat(){ System.out.println("1"); } } interface UserService1{ void hello(); }
异常机制
-
检查性异常
-
运行时异常
-
错误ERROR
-
Java把异常当作对象处理，并定义一个基类java.lang.Throwable作为所有异常的超类
-
处理异常的机制，抛出异常，捕获异常。异常处理的五个关键字
- try、catch、finally、throw、throws
-
选中代码 按Ctrl+Alt+t进行代码段包裹选择如异常，if 等
package com.kuang.exception; public class Test { public static void main(String[] args) { int a = 1; int b = 0; try { new Test().test1(1,0); new Test().test1(1,2); } catch (ArithmeticException e) { System.out.println("hahaha"); } try{ //try监控区域 System.out.println(a/b); }catch(ArithmeticException e){ //catch(想要捕获异常的类型)捕获异常 System.out.println("程序出现异常，变量b不能为0"); }catch(Throwable e){ System.out.println("Throwable"); }finally{//处理善后工作 System.out.println("finally"); } } //假设在方法中，处理不了这个异常，方法上抛出异常 public void test1(int a,int b) throws ArithmeticException{ if(b == 2){ throw new ArithmeticException();//主动抛出异常，一般在方法中使用 } System.out.println(a/b); } } -
自定义异常
package com.kuang.exception; public class MyException extends Exception { //传递数字>10 private int detail; public MyException(int a) { this.detail = a; } //toString:异常的打印信息 @Override public String toString() { return "MyException{" + "detail=@@@@@" + detail + '}'; } }
17万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
