public static void main(String[] args) {
}
缩写sout等于
System.out.println();注释
要经常写注释// 一行注释 一整段注释 数据类型
布尔类型：是非
boolean flag = true; boolean flag1 = false;转义字符 ""
t 制表符n 换行n 回车\ 两个反斜杠表示一个反斜杠 NULL 变量
public class demo1 {
//类变量 static
static double salary = 25000;
//实例变量:从属于对象；如果不自行初始化，这个类型的默认值 0或者0.0
//布尔值默认：false
//除了基本类型，其余的默认值都是null
String name;
int age;
//main方法
public static void main(String[] args) {
//局部变量;必须申明和初始化值
int i = 10;
System.out.println(i);
//变量类型 变量名字=new demo1();
demo1 demo1name=new demo1();
System.out.println(demo1name.age);
//类变量 static
System.out.println(salary);
}
//其他方法
public void add(){
}
}
常量
final 常量名=值；常量名一般用大写字符，全部大写和下划线
static final double PI = 3.1415; //静态常量驼峰原则
除了第一个单词小写，后面的首字母大写类名首字母大写和驼峰原则，如GoodMan 三元运算符
x？y：z 如果x==true，则结果为y，否则结果为z字符串连接符：只要第一个是String类型的，后面的都会转换成String类型
public class demo2 {
public static void main(String[] args) {
int a = 10;
int b = 22;
System.out.println(a+b);
System.out.println(""+a+b);
}
}
输出
32
1022
包机制
包命名要规范import xxxx.xxxx.包名.* 表示导入某包下所有类（*通配符） java流程控制 scanner 基本语法
Scanner s = new Scanner(System.in); 可以用 new Scanner(System.in) 加 Alt+Enter自动补全
通过Scanner类的next()与nextline()方法获取输入的字符串，在读取前我们一般就需要使用hasNext()与hasNextLine()判断是否还有输入的数据
public class Demo1 {
public static void main(String[] args) {
//创建一个扫描器对象，用于接收键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用nextLine方式接受：");
//判断用户有没有输入字符串
if(scanner.hasNext()){
//使用nextLine方式接收
String str = scanner.nextLine();
System.out.println("输出内容为："+ str);
}
scanner.close();
}
}
next()不能得到有空格的字符串
nextLine()可以获得空白，使用范围大（建议使用该方法）
public class Demo2 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//输入
int i=0;
float f=0.0f;
System.out.println("请输入整数");
if (scanner.hasNextInt()){
i = scanner.nextInt();
System.out.println("整数数据为：" + i);
}else{
System.out.println("输入的不是整数");
}
System.out.println("请输入小数：");
if (scanner.hasNextFloat()){
f = scanner.nextFloat();
System.out.println("小数数据为：" + f);
}else{
System.out.println("输入的不是小数");
}
}
}
请输入整数
20
整数数据为：20
请输入小数：
0.33
小数数据为：0.33
进阶使用
public class Demo4 {
public static void main(String[] args) {
//输入多个数字，并请求总和和平均值，每输入一个数字用回车确认，通过输入非数字并输出执行结果
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数据");
//和
double sum = 0;
//计算输入多少个数字
int m = 0;
//通过循环判断是否还有输入，冰在里面对每一次进行求和和统计
while(scanner.hasNextDouble()){
double x = scanner.nextDouble();
m = m + 1;//m++
sum = sum + x;
System.out.println("你输入了第" + m + "个数据，当前sum值为：" + sum);
}
System.out.println(m+"个数的和为"+sum);
System.out.println(m + "个数的平均值为" + (sum / m));
scanner.close();
}
}
请输入数据
10
你输入了第1个数据，当前sum值为：10.0
13
你输入了第2个数据，当前sum值为：23.0
253
你输入了第3个数据，当前sum值为：276.0
+
3个数的和为276.0
3个数的平均值为92.0
Process finished with exit code 0
结构
顺序
选择
switch
public class Demo1 {
public static void main(String[] args) {
char grade = 'C';
switch(grade){
case 'A':
System.out.println("优秀");
break;
case 'B':
System.out.println("良好");
break;
case 'C':
System.out.println("及格");
break;
case 'D':
System.out.println("勉强");
break;
case 'E':
System.out.println("挂科");
break;
default:
System.out.println("非法输入");
}
}
}
及格
循环
while
public class Demo2 {
public static void main(String[] args) {
int i = 0;
while(i<100){
i++;
System.out.println(i);
}
}
}
do…while…
public class Demo2 {
public static void main(String[] args) {
int i = 0;
int sum = 0;
do {
sum = sum + i;
i++;
} while (i <= 100);
System.out.println(sum);
}
}
5050
for
九九乘法表
public class Demo3 {
public static void main(String[] args) {
for (int i = 1; i < 10; i++) {
for (int y = 1; y <= i; y++) {
System.out.printf(i+"*"+y+"="+(i*y)+"t");
}
System.out.println("n");
}
}
}
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
加强for循环
public class Demo4 {
public static void main(String[] args) {
int[] numbers = {10, 20, 30, 40};
for(int x:numbers){ //对数组的遍历
System.out.println(x);
}
}
}
debug
打一个断点，再点小虫子，一步一步来
java方法public class Demo1 {
public static void main(String[] args) {
int sum = add(1, 2);
System.out.println(sum);
}
//加法
public static int add(int a,int b){
return a + b;
}
}
定义
方法是语句的集合，他们在一起执行一个功能
一个方法最好只做一个功能
重载在一个类中， 相同的方法名称，形参不同的函数
可变参数在方法声明中，在指定参数类型后加一个省略号（…）
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
public class Demo2 {
public static void main(String[] args) {
Demo2 demo=new Demo2();
demo.test();
}
public void test(int... i){
System.out.println(i);
}
}
递归
自己调用自己
递归结构包括两个部分：
递归头：什么时候不调用自身方法、如果没有头，将陷入死循环递归体：什么时候需要调用自身方法
public class Demo3 {
public static void main(String[] args) {
int i=0;
Scanner scanner = new Scanner(System.in);
System.out.println("请输入整数");
i = scanner.nextInt();
System.out.println("该数据的阶乘为："+f(i));
}
//阶乘!
public static int f(int n){
if (n==1){
return n;
}else{
return n * f(n - 1);
}
}
}
请输入整数
3
该数据的阶乘为：6
方法的调用
//引用的类
public class Demo1 {
//非静态方法
public void say(){
System.out.println("引用Demo1的类");
}
}
public class Demo2 {
public static void main(String[] args) {
//实例化这个类：new Demo1();
Demo1 demo1 = new Demo1();
demo1.say();
}
}
数组
定义
public class Demo1 {
public static void main(String[] args) {
//声明数组
int[] nums;//首选
//int num1[];这个也可以
int sum=0;
//创建数组
nums = new int[10];
nums[1]=1;
nums[2]=2;
for (int i = 0; i < nums.length; i++) {
sum += nums[i];
}
System.out.println(sum);
}
}
初始化
public class Demo2 {
public static void main(String[] args) {
//静态初始化
int[] a = {1, 2, 3, 4, 5, 6};
//动态初始化
int[] b = new int[10];
b[0] = 10;
System.out.println(b[0]);
}
}
Arrays类
public class Demo3 {
public static void main(String[] args) {
int[] a = {1, 2, 3, 4, 5456, 456, 213, 654};
System.out.println(a);
//打印数组元素Arrays.toString
System.out.println(Arrays.toString(a));
}
}
[I@776ec8df
[1, 2, 3, 4, 5456, 456, 213, 654]
面向对象
本质
以类的方式组织代码，已对象的组织（封装）数据
对象对象是抽象概念的具体实例
public class Student {
String name;
int age;
}
public class UseStudent {
public static void main(String[] args) {
Student xiaoming = new Student();
Student xiaohong = new Student();
xiaoming.name = "小明";
xiaohong.name = "小红";
xiaoming.age = 12;
xiaohong.age = 44;
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
System.out.println(xiaohong.name);
System.out.println(xiaohong.age);
}
}
构造器
构造器：
- 和类名相同没有返回值
作用：
- new本质再调用构造方法初始化对象的值
注意点：
- 定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
快捷键：
alt+Insert
public class Person {
//一个类什么都不写，它也会存在一个方法
//显示的定义构造器
String name;
int age;
//alt+insert快捷键按出有参和无参的构造器
//使用new关键字，本质是再调用构造器
//用来初始化值
public Person() {
}
//有参构造：一旦定义了有参构造，无参就必须显式定义
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
public class Application {
public static void main(String[] args) {
//new实例化一个对象
Person person = new Person();
System.out.println(person.name);
}
}
封装
属性私有，get/set
快捷键：alt+insert
public class Student {
//属性私有
private String name;
private int id;
private char sex;
//提供一些可以操作这是属性的方法
//提供一些public的get、set方法
//get 获得这个数据
public String getName(){
return this.name;
}
//set 给这个数据设置值
public void setName(String name){
this.name = name;
}
}
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("大帅哥");
System.out.println(s1.getName());
}
}
继承
用final修饰的不能继承
extends 继承父类所有的方法
java中只有单继承，一个儿子只有一个爸爸；但是一个爸爸可以有多个爸爸
快捷键：ctrl+H 可以打开继承树（IDEA）
super VS this- super调用父类的构造方法，必须在构造方法的第一个super必须只能出现在子类的方法或者构造方法中super和this不能同时调用构造方法
代表的对象不同：
this：本身调用者的这个对象
super：代表父类对象的应用
前提：
this：没有继承也可以使用
super：只能在继承条件才可以使用
构造方法：
this()：本来的构造
super()：父类的构造
方法的重写重写都是方法的重写，与属性无关静态方法和非静态方法区别很大重写的必须是public子类继承父类才能重写方法名必须相同参数列表必须相同修饰符范围可以扩大 public>protexted>default>private抛出的异常可以别缩小，但不能扩大alt+InsertOverride注释
public class A {
public void test(){
System.out.println("A");
}
}
public class B extends A{
//Override 重写
@Override //注解：有功能的注释！
public void test(){
System.out.println("B");
}
}
public class Application {
public static void main(String[] args) {
A a = new A();
a.test();
B b = new B();
b.test();
}
}
多态
- 多态是方法的多态，属性没有多态父类和子类，有联系，类型转换异常！ ClassCastException(父子类异常)存在条件：继承关系，方法需要重写
对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
类型转换父类转换成子类，向下转型：强制转换
static（静态）一个类里,非静态的方法可以调用静态里的所有东西；反之，则不可以
public class Demo1 {
public void run(){
go();
}
public static void go(){
run();//报错
}
}
抽象类（abstract）
- abstract，抽象方法，只有方法名字，没有方法的实现不能new这个抽象类，只能靠子类去实现它；就是约束！抽象类的所有方法，继承了它的子类，都必须要实现他的方法，除非子类也是抽象类，那就让子子类来实现抽象类中可以写普通的方法抽象方法必须在抽象类中
接口自己无法写方法
可以多继承implements，但是继承的子类里要重写
public interface Demo1 {
void add();
}
public interface Demo2 {
void update();
}
public class Demo3 implements Demo1,Demo2{
@Override
public void add() {
}
@Override
public void update() {
}
}
接口中所有定义其实都是抽象的public abstract
可以直接写一个返回值类型+方法名
public interface Demo1 {
void add(int a);//返回值类型 方法名（参数）
}
一个java类中可以有多个class类，但是只能有一个public class类
可以获得外部类的私有属性
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);
}
}
}
public class Application {
public static void main(String[] args) {
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.in();
}
}
异常（Exception）
快捷键：ctrl+alt+t
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uEYgfZSr-1647743652250)(C:Users96501AppDataRoamingTyporatypora-user-imagesimage-20220318140038081.png)]
public class Test {
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");
}
}
}
