【JAVA入坑】【持续更新中】初识Java【Java基础语法】

其他 2021-11-22 03:26:24 阅读次数: 0

初识Java

[by_041]

文章目录

基本概述

Tips

类与对象的特点表现在：封装、继承、多态

函数在Java中叫方法

  • Hello World ~
/*
	Hello.java
*/
public class Hello{
    
    
	public static void main(String[] args){
    
    
		System.out.println("Hellos收到");
	}
}

// 下面是专业注释,可以被javadoc.exe(JDK自带)提取，并放到帮助文档中
/**
*	but ,,
*	this way
*	only support
*	English!!!!!!
*/

输入输出

输出

  • 标准输出：System.out.print()

  • 换行输出：System.out.println()

  • 格式化输出：

    System.out.printf("%N.Mf",d);//Java下的printf只区分整数("%8d")和实数("%8.8f")

System.out.println(String.format("%.Mf",x));


double num = reader.nextDouble();
int zheng_shu = (int)num;
double xiao_shu = num - zheng_shu;
java.text.DecimalFormat ge_shi1 = new java.text.DecimalFormat("0.000");
java.text.DecimalFormat ge_shi2 = new java.text.DecimalFormat(".000");
System.out.println(num+"\n"
                   +zheng_shu+"\n"
                   +ge_shi1.format(xiao_shu)+"\n"
                   +ge_shi2.format(xiao_shu));

输入

//引入java.util(实用包)中的Scanner
import java.util.Scanner;//也可以直接引入实用包的所有：import java.util.*;
//创建Scanner对象，接受从控制台输入
Scanner reader=new Scanner(System.in);
//返回对应类型的标准输入函数：
reader.nextBoolean();
reader.nextByte();
reader.nextShort();
reader.nextInt();
reader.nextLong();
reader.nextFloat();
reader.nextDouble();
reader.nextLine();		//输入一行字符串
//赋值格式：Type_ val = reader.nextType_();
Scanner reader=new Scanner(System.in);
String str=reader.nextLine();

数据类型相关

数据类型 - 基本内容

  • 简单类型：(基本类型)

    • 逻辑类型：boolean
    • 整数类型：byte、short、int、long
    • 字符类型：char
    • 浮点类型：float、double

    和C\C++不同的有：

    原来的bool在Java中是boolean，

    多了byte类型（占一字节，表示范围：-128~127）

    char类型使用Unicode编码，占2字节（可识别65536种字符）

  • 引用类型：（实质就是指针！！！）

    • 数组：

      //定义：
int a[],b[][];//等价于:int[] a,b[];//p.s.Java中申请数组时不能设置长度
a=new int[10];//分配元素，同C/C++
//遍历：
int a[]={
        
        1,2,3,4};
for(int i=0;i<a.length;i++){
        
        	//传统方法
    System.out.println(a[i]);
}
for(int i:a){
        
        					//类似C++11的auto方法
    System.out.println(i);
}

    • 类（包括对象）

      //完整的例子
import java.util.*;


//创建类
class T_
{
        
        
	//参数列表
	int a;			//每个实体各有一个a
	static int b;	//每个实体共用一个b
		//还可设置private/protected/public权限属性
	
	//构造方法
	T_()
	{
        
        a=101;b=102;};	//设置默认值
	T_(int v1)
	{
        
        a=v1;b=102;};
	T_(int v1,int v2)
	{
        
        a=v1;b=v2;};
	
	protected void finalize()
	{
        
        
		output();
	}
	
	//其他方法
	void output(String str)
	{
        
        
		System.out.println(str+(str==""?"":" : ")+a+" "+b);
	}
	
	void output()
	{
        
        
		output("");
	}
	
	T_ cloned()
	{
        
        
		return new T_(this.a,this.b);
	}
	
}


class Main
{
        
        
	
	static Scanner reader = new Scanner(System.in);
	
	public static void main(String[] args)
	{
        
        
		
		T_ t1 = new T_();		//创建T_类实例
		t1.output("t1");
		
		T_ t2 = new T_(11,12);
		t2.output("t2");
		t1.output("t1");
		
		T_ t3 = t1;				//t3的内存地址（指针）指向t1的内存地址（实例）
		t3.output("t3");
		
		t1=t2.cloned();
		t1.a=1;
		t2.a=2;
		t2.output("t2");
		t1.output("t1");
		
		T_ ts[] = new T_[10];	//相当于指针数组
		System.out.println("ts - < "+ts.length+" > :");
		for(int i=0;i<ts.length;i++)
			ts[i] = new T_(i,i);
		for(int i=0;i<ts.length;i++)
			ts[i].output("ts [ "+i+" ]");
	}

}

    • 接口（interface）

      封装私有化变量，设置interface方法调用其的操作即为接口操作

  • 运算符号：

    • 运算符优先级：

      优先级 描述 运算符 结合性
      1 分隔符 [] () . , ; 右到左
      2 对象归类、自增自减运算、逻辑非 instanceof、++、– 左到右
      3 算数乘除运算 *、/、% 左到右
      4 算数加减运算 +、- 左到右
      5 位移运算 >>、<<、>>> 左到右
      6 大小关系运算 <、<=、>、>= 左到右
      7 相等关系运算 ==、!= 左到右
      8 按位与运算 & 左到右
      9 按位异或运算 ^ 左到右
      10 按位或运算 | 左到右
      11 逻辑与运算 && 左到右
      12 逻辑或运算 || 左到右
      13 三目条件运算 ? : 左到右
      14 赋值运算 = 右到左

      [对象名] instanceof [类名] ：返回左面的对象是否是右边的类或子类创建的对象（返回“左属于右？”）

      >>> ：无符号右移。无论是正数还是负数，高位通通补0。（“不管符号位的特殊在二进制上直接位移”）

控制命令

判断/选择/循环

完全同C/C++一致

方法(函数)

与C/C++基本一致

  • 参数：
void func(double x,int ... a){
    
    
    //第一个参数是x,剩下的会以x为代表(x[0..n])
	...;
}

修饰符:

参考CSDN博文

  • 访问权限修饰符
    • public:共有访问。对所有的类都可见。
    • protect:保护型访问。对同一个包可见，对不同的包的子类可见
    • (default/friendly):默认访问权限。只对同一个包可见，注意对不同的包的子类不可见。
    • private:私有访问。只对同一个类可见，其余都不见。
  • 非访问权限修饰符
    • static:
      静态;用来创建类方法和类变量
    • final:
      终焉;被修饰的类不能被继承，被修饰的方法不能被继承类重新定义，被修饰的变量为常量，不可修改
    • abstract:
      抽象;用来创建抽象类的和抽象方法
    • synchronized:
      使同步;用于多线程的同步
    • volatile:
      不稳定;被修饰的变量每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。且其发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同线程总是看到某个成员变量的同一个值
    • transient:
      短暂;序列化的对象包含被其修饰的实例变量时，JVM跳过该特定的变量

类与类的关系以及实现

继承父类：extend

  • 用于继承，格式：class ChildClass extends FatherClass{}
  • 父类指针可以指向子类内容，但是不能调用父类本身没有定义的内容

父类：super

  • 在子类中调用父类用，使用时等于使用当前实例的父类方法（例子中的Bclass类的out()方法里有体现）
  • 一个子类只能有一个父类，Java不支持多继承

抽象：abstract

  • 构建抽象类，一个概念，只能有方法列表,不能有主体（{}以及其中内容）
  • 如果一个类继承了一个抽象类，那么这个类必须重写（override）这个抽象类的所有方法

接口：interface

  • 是一种抽象类，也不能实例化

  • 接口中的变量自动都是：public、static、final

  • 接口中的方法默认为：public、abstract；编译后也产生class文件

  • 接口中的方法不能被static和final修饰，因为要重写（override）接口中的所有构造方法

  • 接口中没有构造函数；方法可以抛出异常

  • 接口里的数据可以直接使用（不需要new出实例）

  • 接口最大的作用是把俩原来不相干的类相关

使用接口：implements

  • 使用：class Aclass (exterds AFatherClass) implements A,B,C...//接口列表
  • 如果一个类继承了一个接口，那么这个类必须重写（override）这个接口的所有方法
  • Java可以使用多个接口，间接的可以实现多继承

Here is a 例子：

//Main.java

import java.util.*;

abstract class AbstractOne
{
    
    
	//只能有方法列表不能有主体以及其中内容
	abstract void out();
}

class Aclass extends AbstractOne
{
    
    
    //必须完全覆盖抽象父类
	void out()
	{
    
    
		System.out.println("A - out()");
		return;
	}
	int a()//AbstractOne调用不到
	{
    
    
		return 1;
	}
}

class Bclass extends Aclass
{
    
    
	void out()
	{
    
    
		System.out.println("B - out() - begin");
		super.out();			//使用父类方法
		System.out.println("B - out() - release");
		return;
	}
}


interface Ainterface
{
    
    
	//参数列表
	int INT_MAX=2147483647;
	long LONG_MAX=0x7fffffff;
	int INT_MIN=-2147483648;
	long LONG_MIN=0x80000000;
	//方法列表
	void out();
}

class Cclass implements Ainterface
{
    
    
	public void out()
	{
    
    
		System.out.println("C - out() : int-max = "+INT_MAX);
		System.out.println("C - out() : long-max = "+LONG_MAX);
		return;
	}
}
class Dclass implements Ainterface
{
    
    
	public void out()
	{
    
    
		System.out.println("D - out() : int-min = "+INT_MIN);
		System.out.println("D - out() : long-min = "+LONG_MIN);
		return;
	}
}

public class Main
{
    
    
	
	static Scanner reader=new Scanner(System.in);
	
	public static void main(String[]args)
	{
    
    
		(new Bclass()).out();
/*
结果为：
B - out() - begin
A - out()
B - out() - release
*/
		System.out.println("=================================");

		AbstractOne ab;
		ab = new Aclass();
		ab.out();
/*
结果为：
A - out()
*/
		System.out.println("===============");
		ab = new Bclass();
		ab.out();
/*
结果为：
B - out() - begin
A - out()
B - out() - release
*/
		System.out.println("===============");
		Aclass ac;
		ac = new Bclass();
		ac.out();
/*
结果为：
B - out() - begin
A - out()
B - out() - release
*/
		System.out.println("===============");
		// Bclass bc;
		// bc = new Aclass();//不行子类指针不能指向父类实例
		// bc.out();


		System.out.println("=================================");

		Ainterface ai;
		ai = new Cclass();
		ai.out();
		ai = new Dclass();
		ai.out();
/*
结果为：
C - out() : int-max = 2147483647
C - out() : long-max = 2147483647
D - out() : int-min = -2147483648
D - out() : long-min = -2147483648
*/

		System.out.println("=================================");

		System.out.println("Done in Mian()");

		return;
	}
}
/*

结果为：
B - out() - begin
A - out()
B - out() - release
=================================
A - out()
===============
B - out() - begin
A - out()
B - out() - release
===============
B - out() - begin
A - out()
B - out() - release
===============
=================================
C - out() : int-max = 2147483647
C - out() : long-max = 2147483647
D - out() : int-min = -2147483648
D - out() : long-min = -2147483648
=================================
Done in Mian()

*/

导入类

  • 【在sublime配置为Java时（命令台版本不会）】

    public class [class_name]{}只能在同名文件[class_name].java中声明

import - 引入类库中的类（常用类）

基本语法：import [包名].[类名/*];

  • 常用的包：
java.lang	//包含所有基本语言类
java.swing	//包含抽象窗口工具集中的图形、文本、窗口GUI类
java.io		//包含所有输入/输出类
java.util	//包含实用类
java.sql	//包含操作数据库的类
java.net	//包含实现网络功能的类

java.util.*
java.util.Scanner
java.util.Date
...

书写规范

  • Allmans风格（“独行”）
void func()
{
    
    
	...;
}
  • Kernighan风格（“行尾”）
void func(){
    
    
	...;
}

进阶操作

  • 异常处理+内存释放（垃圾处理）
public class Main{
    
    
	public static void main(String[] args){
    
    
		assert 1==1;
		int a[]=new int[10];
		a[11]=1;
		a=null;
		System.gc();
		try
		{
    
    
			a[11]=1;
			// throw new Exception("123");
		}
		catch(Exception e)
		{
    
    
			System.out.println(e);
		}
		System.out.println("proper - end");
	}
}

猜你喜欢

转载自blog.csdn.net/qq_42710619/article/details/115442296
今日推荐
周排行
8种防盗链的方法
php的序列化和反序列化
Java 8：CompletableFuture
Android版本差异适配方案(5.0-9.0)
makedownpad使用
Spring Boot 使用AOP切面实现后台日志管理模块
实战SSM_O2O商铺_44【DES加密】 关键配置信息进行DES加密
ACM排行榜说明
【转】SQL重复记录查询
板球和秃子威力那个大
每日归档
更多
2024-09-15(0)
2024-09-14(0)
2024-09-13(0)
2024-09-12(0)
2024-09-11(0)
2024-09-10(0)
2024-09-09(0)
2024-09-08(0)
2024-09-07(0)
2024-09-06(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022