java基础

注释

单行注释：// 注释
多行注释：/* 注释 */
文档注释（文档具有功能）：/**回车

/**
*@author 作者名
*@version 版本号
*@since 指明最早使用的jdk版本
*@param 参数名
*@return 返回值情况
*@throws 异常抛出情况
*/
- cmd：javadoc -encoding UTF-8 -charset UTF-8（参数） java文件（生成文档）

标识符

关键字

abstract	assert	boolean	break	byte
case	catch	char	class	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

标识符

 public class Hello{
    public static void main(String[] args){
        System.out.println("Hello World!");
        String student = "米线"；
    }
}

类名：Hello

方法名：main

变量名：student

只能以字母、$、_开始
不能用关键字

数据类型

所以变量定义后才能使用

基本类型

数值类型

整数
- byte（1字节）
- short（2字节）
- int（4字节）
- long（8字节）
```
 long num = 10L;//long类型加L
```
二进制：0b
八进制：0
十六进制：0x
浮点
- float（4字节）
```
 float num = 1.1F;//float类型加F
```
- double（8字节）
避免使用浮点数进行比较

eg：银行业务可以用BigDecimal类（数学工具类）
字符（2字节）

unicode编码：每个数字对应一个字符
```
 System.out.println('\u0061');//a
```

boolean类型（布尔值）（true/false，1位）

转义字符	意义	ASCII码值（十进制）
\b	退格(BS) ，将当前位置移到前一列	008
\f	换页(FF)，将当前位置移到下页开头	012
\n	换行(LF) ，将当前位置移到下一行开头	010
\r	回车(CR) ，将当前位置移到本行开头	013
\t	水平制表(HT) （跳到下一个tab位置）	009
\v	垂直制表(VT)	011
\\	代表一个反斜线字符'\'	092
\'	代表一个单引号（撇号）字符	039
\"	代表一个双引号字符	034
\0	空字符(NULL)	000
\ddd	1到3位八进制数所代表的任意字符	三位八进制
\uhhhh	1到2位十六进制所代表的任意字符	二位十六进制

引用类型

类
接口
数组

类型转换

低--------------------------------------------------------->高

byte，short，char -> int -> long -> float -> double

强制转换：(类型)变量名高 -> 低

自动转换：低 -> 高

eg：

不能对布尔值进行转换
不能把对象类型转换为不相干的类型
转换的时候可能存在内存溢出，精度问题

 //数字之间可以用下划线分割,一般用于大数
int num = 10_000;

变量作用域

 public class Hello{
    String name;
    int age;  //实例变量：从属于类，可以不用初始化（布尔值默认false）
    static double salary = 3000;  //类变量
    
    public static void main(String[] args) {
        int i = 1;  //局部变量：需要初始化
        System.out.println(i);
 
        Hello hello = new Hello();
        System.out.println(hello.age);  //实例变量需要new才能使用
        System.out.println(hello.name);
        
        System.out.println(salary);  //类变量可以直接使用
    }
}

常量

 final double PI = 3.14;
static final double PI =3.14;
final static double PI =3.14; //final和static都为修饰符，不区分顺序

变量命名

一般变量：小驼峰
方法名：小驼峰
类名：大驼峰
常量：大写字母、下划线（MAX_VALUE）

字符串连接符：+

 int a = 10;
int b = 20;
System.out.println(""+a+b);  //1020
System.out.println(a+b+""); //30

包机制

一般利用公司域名倒置作为包名（eg：com.baidu.www）

流程控制

Scanner对象

用来获取用户的输入

Scanner s = new Scanner(System.in);

String str = s.nextLine(System.in);

获取字符串：nex（）、nextLine（）

判断是否还有输入的数据：hasNext（）、hasNestLine（） 一般在读取数据前判断

用完之后要关掉：s.close();

增强For循环

循环数组和集合

for (声明语句：表达式){

}

 int[] numbers = {10,20,30,42};
for(int x:numvers){
    System.out.println(x);
}

方法

 public static void Hello(){
    System.out.prinln("Hello World!");
}

public 公共的

static 静态方法：独立该类的任何对象，不依赖类特定的实例，被类的所有实例共享

能直接调用，不是static方法则需要实例化才能调用

static方法不能调用非static方法 （static方法与类同时加载，非static方法在类实例化之后才加载）

void 返回值

值传递：复制实参的值给形参
引用传递：对于对象，可以改变对象的属性，本质还是值传递

方法的重载

方法名相同，但形参不同

方法名相同
参数列表不同
返回类型可以相同可以不同
仅仅返回类型不同不足以成为方法的重载

方法名相同时，编译器根据调用方法的参数个数、类型等去匹配对应的方法

命令行传参

cmd：java文件路径下编译文件 -> 退回到src文件下运行（eg：java com.method.Demo01）并传参

可变参数

在方法声明中，在指定参数后加省略号

一个方法只能指定一个可变参数且必须时方法的最后一个参数

 public static int add(int... num){
    
}

数组

创建：dateType[] arrayRefVar = new dateType[arraySize];

Arrays类

面向对象

实质：以类的方式组织代码，以对象的组织（封装）数据

一个类中只能有一个public

创建对象

使用new关键字创建对象

 public class Student{
    String name;
    int age;
    public void study(){
        System.out.println(this.name+"在学习")；
    }
}

 public class Application{
    public static void main(String[] args){
        Student lihua = new Student;
        System.out.println(lihua.name);
        lihua.study();
    }
}

类的构造器（构造方法）

实例化时会自动隐式定义，也可显示定义
- 必须与类的名称相同
- 没有返回类型（不是void）
能实例化初始值
定义了有参构造，无参构造就必须显示定义（尽量把无参构造显化）

封装

高内聚，低耦合

数据的隐藏

属性私有：private关键字

 private int name;

get/set方法：可以操作私有属性

 public String getName{
    return this.name;
}
public void setName(String name){
    this.name = name;
}

继承

对一批类的抽象

拓展：extends

 public class Person{
    
}

 public class Student extends Person(){
    
}

类只有单继承，没有多继承

java中所有的类都默认继承Object类

this关键字：引用当前对象
super关键字：引用父类对象

构造器

子类构造器默认调用父类构造器

调用构造器必须是构造函数主体的第一条语句（this()、super()）

 public class Person{
    
}
public class Student extends Person(){
    public Student(){
        //super();默认调用父类构造器
    }
}

方法的重写

重写（Override）都是方法的重写，与属性无关

 public class B(){
    public static void text{
        System.out.println("B->text()");
    }
}

 public class A extends B{
    public static void text(){
        System.out.println("A->text()");
    }
}

 public class A extends B{
    public static void main(String[] args){
        A a = new A();
        a.text();/*静态方法：A->text()
        		   非静态方法：A->text()
        		  */
        
        B b = new A();//父类的引用指向了子类
        b.text();/*静态方法：B->text()
        		   非静态方法：A->text()
        		  */
    }
}

静态方法：方法调用只和定义的数据类型有关
非静态方法：重写了父类的方法，调用时使用的是重写了之后的方法（需要用public）
修饰符：public > protected > default(默认) > private（范围可以扩大但不能缩小）

多态

同一方法可以根据发送对象的不同而采用不同的行为方式

一个对象的实际类型是确定的，指向的引用类型不确定

 Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();

对象能执行的方法主要看定义的类型
多态存在的必要条件
- 继承
- 重写
- 父类引用指向子类对象
关键字instanceof：a instanceof b判断两个对象之间是否存在父子关系（a（a的实际类型）是否是b的子类）

static

类加载时static方法就加载

 public class Demo{
    static{}//静态代码块，最先加载，只执行一次
    {}//匿名代码块，其次加载，可以用来赋初值
    public Demo(){}//构造器，最后加载
}

静态导入包:可以直接使用方法

 import static java.lang.Math.random;

抽象类

关键字：abstract

不能new抽象类

抽象类里可以写普通方法

抽象方法必须在抽象类中

 //抽象类
public abstract class Action{
    //约束，抽象方法
    public abstract void doSomething();
}

继承了抽象类的子类必须实现抽象类的方法，除非子类也是抽象类

抽象类也存在构造器

接口

只有规范，不能写方法，实现约束和实现分离：面向接口编程

关键字：interface

 public interface UserService{
    //接口中的所有定义都是抽象的：public abstract（方法）、public static final（属性）
    void add();
}

 public interface TimeService{
    void time();
}

接口都需要有实现类

接口可以多继承

 //命名规则:接口名加Impl，用关键字implements实现
public UserServiceImpl implements UserService,TimeService{
    public void add(){
        
    }
    public void time(){
        
    }
}

内部类

成员内部类，静态内部类

 public class Outer{
    private int id;
    public void out(){
        System.out.println("外部")；
    }
    public class Inner{
        public void in(){
            System.out.println("内部")；
        }
        //能获得外部类的私有属性，加static之后（静态内部类）则不能获得
        public void getID(){
            System.out.println(id)；
        }
    }
}
//实例化
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();

 public class Demo01{
    
}
//一个类文件中只能有一个public类
class Demo02{
    
}

局部内部类

 public class Demo01{
    public void method(){
        class Inner{
            public void in(){
                
            }
        }
    }
}

匿名内部类

 public class Demo01{
    public void run(){
        
    }
}

 new.Demo01().run();//没有名字

posted @ 2022-05-08 11:22 深巷の猫阅读(27) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 注解和反射

· java基础

· Java基础入门

· Java基础学习笔记（狂神说Java）

阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· DeepSeek 开源周回顾「GitHub 热点速览」
· 记一次.NET内存居高不下排查解决与启示
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了

公告

昵称：深巷の猫
园龄： 2年9个月
粉丝： 1
关注： 1

+加关注

2025年3月

日

一

二

三

四

五

六

	public class Hello{
	public static void main(String[] args){
	System.out.println("Hello World!");
	String student = "米线"；
	}
	}

	//数字之间可以用下划线分割,一般用于大数
	int num = 10_000;

	public class Hello{
	String name;
	int age; //实例变量：从属于类，可以不用初始化（布尔值默认false）
	static double salary = 3000; //类变量

	public static void main(String[] args) {
	int i = 1; //局部变量：需要初始化
	System.out.println(i);

	Hello hello = new Hello();
	System.out.println(hello.age); //实例变量需要new才能使用
	System.out.println(hello.name);

	System.out.println(salary); //类变量可以直接使用
	}
	}

	final double PI = 3.14;
	static final double PI =3.14;
	final static double PI =3.14; //final和static都为修饰符，不区分顺序

	int a = 10;
	int b = 20;
	System.out.println(""+a+b); //1020
	System.out.println(a+b+""); //30

	int[] numbers = {10,20,30,42};
	for(int x:numvers){
	System.out.println(x);
	}

	public static void Hello(){
	System.out.prinln("Hello World!");
	}

	public class Student{
	String name;
	int age;
	public void study(){
	System.out.println(this.name+"在学习")；
	}
	}

	public class Application{
	public static void main(String[] args){
	Student lihua = new Student;
	System.out.println(lihua.name);
	lihua.study();
	}
	}

	public String getName{
	return this.name;
	}
	public void setName(String name){
	this.name = name;
	}

	public class Person{

	}
	public class Student extends Person(){
	public Student(){
	//super();默认调用父类构造器
	}
	}

	public class B(){
	public static void text{
	System.out.println("B->text()");
	}
	}

	public class A extends B{
	public static void text(){
	System.out.println("A->text()");
	}
	}

	public class A extends B{
	public static void main(String[] args){
	A a = new A();
	a.text();/*静态方法：A->text()
	非静态方法：A->text()
	*/

	B b = new A();//父类的引用指向了子类
	b.text();/*静态方法：B->text()
	非静态方法：A->text()
	*/
	}
	}

	Student s1 = new Student();
	Person s2 = new Student();
	Object s3 = new Student();

	public class Demo{
	static{}//静态代码块，最先加载，只执行一次
	{}//匿名代码块，其次加载，可以用来赋初值
	public Demo(){}//构造器，最后加载
	}

	//抽象类
	public abstract class Action{
	//约束，抽象方法
	public abstract void doSomething();
	}

	public interface UserService{
	//接口中的所有定义都是抽象的：public abstract（方法）、public static final（属性）
	void add();
	}

	//命名规则:接口名加Impl，用关键字implements实现
	public UserServiceImpl implements UserService,TimeService{
	public void add(){

	}
	public void time(){

	}
	}

	public class Outer{
	private int id;
	public void out(){
	System.out.println("外部")；
	}
	public class Inner{
	public void in(){
	System.out.println("内部")；
	}
	//能获得外部类的私有属性，加static之后（静态内部类）则不能获得
	public void getID(){
	System.out.println(id)；
	}
	}
	}
	//实例化
	Outer outer = new Outer();
	Outer.Inner inner = outer.new Inner();

cherish-0

java基础

java基础

注释

标识符

关键字

标识符

数据类型

基本类型

引用类型

类型转换

变量作用域

常量

变量命名

包机制

流程控制

Scanner对象

增强For循环

方法

方法的重载

命令行传参

可变参数

数组

面向对象

创建对象

类的构造器（构造方法）

封装

继承

构造器

方法的重写

多态

static

抽象类

接口

内部类

公告

搜索

常用链接

随笔分类

随笔档案

阅读排行榜

	public class Demo01{

	}
	//一个类文件中只能有一个public类
	class Demo02{

	}

	public class Demo01{
	public void method(){
	class Inner{
	public void in(){

	}
	}
	}
	}