Java 基础

一、基础概念：

1.1 Java体系：

Java程序设计语言
各种平台上的Java虚拟机
Java API类库
一系列辅助工具，如javac

1.2 JVM、JDK、JRE：

JVM : 各种平台上的java虚拟机
JDK = 1+2+3+4 (java开发工具包)
JRE = 2+3 (java运行时的环境)

1.3 初识Java程序编译：

.java文件 编译为 class文件（javac.exe）（文件.java）
class文件 解析为可识别文件（java.exe）（文件）

public 唯一，且后面的类名要与文件名一致

二、数组

（引用数据类型，元素用引用方式存储）

2.1 声明

```
int [] arr;
```
定义了一个int类型的数组，数组名是arr。（推荐）(c不行)
```
int arr [];
```
定义了一个int类型的变量，变量名是arr数组。

2.2 初始化

2.2.1 动态初始化：

只给长度，系统给初始化值。

数据类型 [] 数组名 = new 数据类型 [数组长度]
int [] arr = new int [3];

2.2.2 静态初始化：

给初始化值，由系统决定长度。

int [] arr = {1,2,3};

2.2.3 字符串数组初始化：

String names[] = new String[2];
names[0] = "ABC";
names[1] = "DEF";

//静态：

String names[] = {"ABC","DEF"};

数组输入

Scanner sc = new Scanner(System.in); //扫面键盘。
for(int i=0;i<arr.length;i++){
    arr[i]=sc.nextInt();               //#####循环输入数组
}

三、字符串

String类：
每个“ ”定义的字符串都是一个String类的对象，可以通过该类的构造方法来创建字符串。
需导入 java.lang 包
更类似于C++的 char* 类型

	char类型不可以赋值为空，String可以为空。
	char进行+ -时视作ASCII码加减，String的＋视为字符连接。

3.1 实现：

	String str = "Hello";
	StringBuilder b = new StringBuilder();  b.append(char); b.append(string);

			上述可用.toString()方法转化为String对象

B 方法：

1. substring(begin_index)  截取字符串
2. substring(begin_index,end_index) 同上,左闭右开
3. trim()  消除空格
4. replace()  替换成新的字符或字符串
5. startWith(string) / endWith(string)  判断是否以指定内容开始或结束
6. equals(string)  区分大小写判断相等  ***不能用==，否则比较的是内存地址***
7. equalsIgnoreCase(stirng)  无视大小写判断相等
8. charAt(index)	获取字符串指定index的字符

C 字符串/字符数组互换：
String--char[]:

char [] ch = string.toCharArray();

char[]--String:

String str =  String.valueOf(ch);

四、输入输出

快捷键输出：syso & sout & souf ===》加上 alt+/

System.out : 标准的输出设备 System.in : 标准的输入设备。
输入：

     Scanner in = new Scanner(System.in); //扫面键盘。
     String st = in.nextline(); //从键盘获取一个字符串。
     int data1 = in.nextInt(); //从键盘获取一个整数。

输出：

	System..print(“hello world-1”); //打印不加换行。
    System.out.println(“hello world-2”); //打印自动换行。
    System.out.printf(“%s-%d-%c-%s-%f”,“张三”,20,‘m’,“英语”,59.9); 					    //格式化字符打印 %d 整数 %s 字符串 %c符号 %f 浮点数。

格式化输出：（转自：原文地址侵删）

public class TestNumber
{
	public static void main(String[] args)
	{
		String name = "盖伦";
		int kill = 8;
		String title = "超神";
		
		String sentence = name + " 在进行了连续  " + kill + " 次击杀后，获得了 " + title + " 的称号 ";
		//直接使用+进行字符串连接，编码感觉会比较繁琐，并且维护性差，易读性差
		System.out.println(sentence);
		
		String sentenceFormat = "%s 在进行了连续 %d 次击杀后， 获得了 %s 的称号%n";
		//格式化输出，%s表示字符串，%d表示数字，%n表示换号
		System.out.printf(sentenceFormat, name, kill, title);
		System.out.format(sentenceFormat, name, kill, title);
		//format和printf能够达到一模一样的效果
		
		int year = 2020; 
		
		System.out.format("%d%n",year);		//用%n或\n没差
		//直接打印数字
		System.out.printf("%8d%n",year);	//用printf还是format没差
		//总长度为8，默认右对齐
		System.out.printf("%-8d%n",year);
		//总长度为8，默认左对齐
		System.out.printf("%08d%n",year);
		//总长度为8，不够补0
		System.out.printf("%,8d%n",year*10000);
		//千位分隔符
		System.out.format("%.2f%n",Math.PI);
		//小数点位数	
	}	
}

五、类

类与修饰词：
private >>> 缺省 >>> protected >>> public
同类 >>> 同包中 >>> 子类、同包中 >>> 所有

5.1 类的声明：

【修饰符】class 类名 【extends 父类】【implements 接口】

单父类，多接口。

**Java定义完类后不用写 ；
**C++需要写；

5.1.1 对象的比较：

== 和 !=：
比较2个 引用实例 是否相等。
equals()：
比较2个 类内的值 是否相等。

5.1.2 注意：

Javac 文件.java时会生成所有类的 .class文件。
每个类都可以有1个自己的main函数，但仅又一个main函数会执行，其他的可以作为类单元的测试。

5.2 this：

用于指代当前对象自身（谁调用的，当前就是谁）。

 Person a1 = this；

访问当前对象的变量和方法。

 this.变量/方法（参数）

调用本类重载的构造方法。
只可以在构造函数中用，并且写在第一句。

5.3 构造方法：

无返回类型，方法名与class名相同

5.3.1 拷贝构造方法：

Java中没有默认的拷贝构造方法。类采用“引用”，形参实参为1个空间。
当对象作为函数参数或者返回值，传对象引用。

C++中执行的时候传形式参数。

3·import：

不同包的文件可以使用 import 包路径类名 来使用其他包文件。
如果有包的话，package语句必须放到d1行。
如果不同包有同名的类，引用类时必须写出 "包路径.class名" 。

5.4 析构方法

public void finalize(){...;}

名字固定
仅此一个
无参，返回void
子类先 super.finalize()调用父类的析构方法

5.5 继承(extends)：

不支持多继承
可详见接口

class 子 extends 父{
	...
}

父子同一个包：可以继承除private之外的所有。
父子不在同一包：只可以继承父的protected、public成员变量和方法。什么都不写的（默认的）不会继承。

ex：instanceof 运算符：

双目运算符，左面操作对象，右面操作类。
左是右的类或者子类创建的对象时，返回true。

5.6 方法重写与super：

在子类进行与父类完全一致的成员变量或方法会覆盖父类，称之为重写。
如果想使用被隐藏的变量或者方法，使用super.x / super.f()。

6·对象的上转型对象与多态：

假设A父B子：

A a;
B b = new B();
a = b;
或者
A a = new B();

此时 a 无法新增变量或方法。
利用 a 可以使用不同子类的不同方法。----》多态。

5.7 抽象类与多态(abstract)：

abstract class A{
	...
}

抽象类中可以有普通或 abstract 方法。
只可以声明，不能使用 new 运算符创建该类对象。
如果一个非抽象类是某个抽象类的子类，那么必须重写父类的抽象方法。
如果一个抽象类是某个抽象类的子类，那怎样都行。
抽象类中抽象方法只能声明，不可实现。

eg：
父(abstract)： Car
子：PoliceCar、FireCar、etc...
功能类：SoundMaker（内含发声功能）

public class SoundMaker{
	void sound(Car car){
		car.makesound();
	}
}

创建功能性对象： SoundMaker sm = new SoundMaker();
使用对象的上转型对象：父类 car = new 子类();
sm.sound(car);

5.8 接口：

引入原因：Java只允许单继承，但是允许多继承的接口。继承---“是不是”；接口---“能不能”。
接口创建：

public interface 接口名{

	常量（访问权限一定是public，允许忽略public、final）
	public static final int MAX = 100;
	int MAX = 100;//同上
	
	
	方法（访问权限一定是public，允许忽略public、abstract）
	public abstract void add(int a,int b);
	void add(int a,int b);//同上
}

接口使用：
使用 implements 关键字声明自己实现一个个或者多个接口，用“，”隔开。
如果一个类实现了某个接口，就必须重写该接口的方法。

class A implements 接口1，接口2
class Dog extends Animal implements 接口1，接口2

接口特点：

没有构造器。
采用多继承机制。
主要用途就是被实现类实现。
和类是并列关系，一种特殊的抽象类，只包含常量和方法的定义。

posted @ 2020-02-13 13:06 LASER_06 阅读(17) 评论(0) 收藏举报

刷新页面返回顶部

LASER_06