基础语法
1.HelloWorld
public class HelloWorld {
public static void main(String[] args) {
//输出一个Hello world!
System.out.println("Hello world!");
}
}
2.数据类型扩展
public class Demo02 {
public static void main(String[] args) {
//整数扩展
int data1 = 10;
int data2 = 010;
int data3 = 0b000100;
int data4 = 0x10;
System.out.println(data1);
System.out.println(data2);
System.out.println(data3);
System.out.println(data4);
System.out.println("========================");
//浮点数扩展 银行业务用Bigdecimal
float f1 = 0.1f;
double f2 = 1.0 / 10;
float d1 = 1314324143f;
float d2 = d1 + 1;
System.out.println(f1 == f2);
System.out.println(d1 == d2);
System.out.println(f1);
System.out.println(f2);
System.out.println("========================");
//字符扩展
char c1 = '哈';
char c2 = '1';
char c3 = '\u0061';
System.out.println((int)c1);
System.out.println((int)c2);
System.out.println(c3);
System.out.println("Hello\tWorld!");
}
}
3.数据类型强制转换
public class Demo03 {
public static void main(String[] args) {
int i = 128;
byte b = (byte)i; //强制转换
System.out.println(i);
System.out.println(b);
System.out.println("===================");
System.out.println((int)13.8);
System.out.println((int)-65.89f);
System.out.println("===================");
char c = '1';
int data = c + 1;
System.out.println((int)c);
System.out.println(data);
System.out.println(c);
System.out.println((char)data);
}
}
4.变量&常量
public class Demo04 {
//属性:变量
//类变量
static double month = 2;
//常量
//修饰符 修饰符 数据类型 变量名
//修饰符 不存在先后顺序
static final double TIME = 2020;
//实例变量,从属于对象。方法之外,类之内。
//如果不初始化,这个类型的值默认为 0.0.0
//布尔值:默认为false
//除了基本类型,其它都是null
String name;
int age;
//main方法
public static void main(String[] args) {
//局部变量
int a = 1;
System.out.println(a);
//实例变量
Demo04 d04 = new Demo04();
System.out.println(d04.age);
System.out.println(d04.name);
//类变量
System.out.println(month);
//常量
System.out.println(TIME);
}
//其他方法
public void add(){
}
}
5.运算符
package operator;
public class Demo02 {
public static void main(String[] args) {
int a = 3;
int b = a++;
int c = ++a;
double mul ;
boolean m = true;
boolean n = false;
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(a++ + ++b);
mul = Math.pow(4, 2);
System.out.println(mul);
System.out.println("m&&n:" + (m && n));
System.out.println("m||n:" + (m || n));
System.out.println("!(m&&n):" + !(m && n));
}
}
## 6.字符串拼接
```java
public class StringCat {
public static void main(String[] args) {
int a = 10;
int b = 20;
//字符串在前拼接,直接拼接输出字符串
//字符串在后拼接,先计算再拼接输出字符串
System.out.println("" + a + b); //1020
System.out.println(a + b + ""); //30
}
}
7.包机制
为了能够更好的组织类,Java提供了包机制,用于区别类名命名空间。
package pkg1[. pkg2[. pkg3…]];
为了能够使用某一个包的成员,需要在Java程序中明确导入改包,使用import语句完成该功能。
import pkg1[. pkg2[. pkg3…]];
一般用公司域名倒置为包名
例如package com.baidu.www
package com.ysc.base; //包名
import import java.util.*;//导入这个包下面的所有类
public class StringCat {
public static void main(String[] args) {
int a = 10;
int b = 20;
//字符串在前拼接,直接拼接输出字符串
//字符串在后拼接,先计算再拼接输出字符串
System.out.println("" + a + b); //1020
System.out.println(a + b + ""); //30
}
}
8.Scanner对象
Scanner类为java提供的工具类,我们可以用Scanner类来获取用户的输入。基本语法为
Scanner scanner = new Scanner(System.in);
我们可以通过Scanner类的next()与nextLine()来获取输入的字符串,在读取之前我们一般使用hasNext()与hasNextLine()判断是否还有输入的数据。
scanner对象的两种接收输入方法:
next()
- 一定是读取到有效字符后才可以结束输入。
- next()方法不能得到带有空格的字符串。
package com.ysc.scanner;
import java.util.Scanner;
public class DemoScanner {
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("next方式的输入内容为:"+str);
}
//IO流的类如果不关闭会一直占用资源,用完就要关闭。
scanner.close();
}
}
nextLine()
- Enter输入作为结束符,能够获取到Enter之前的所有输入字符
package com.ysc.scanner;
import java.util.Scanner;
public class DemoScanner1 {
public static void main(String[] args) {
Scanner scanner1 = new Scanner(System.in);
System.out.println("使用nextLine方式接收");
if(scanner1.hasNextLine()){
//使用nextLine接收
String str1 = scanner1.nextLine();
System.out.println("nextLine方式的输入内容为:"+str1);
}
//IO流的类如果不关闭会一直占用资源,用完就要关闭。
scanner1.close();
}
}
package com.ysc.scanner;
import java.util.Scanner;
public class DemoScannerNextLine {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入内容:");
scanner.hasNextLine();
//使用nextLine接收
String str1 = scanner.nextLine();
System.out.println("输入内容为:\n" + str1);
//IO流的类如果不关闭会一直占用资源,用完就要关闭。
scanner.close();
}
}
9.求输入数字的和与平均值
package com.ysc.scanner;
import java.util.Scanner;
public class DemoScannerSumAndAvrg {
public static void main(String[] args) {
//输入多个数,并求其和与平均值,每输一个数字用回车确认,通过输入非数字符结束并输入结果
double sum = 0;
double temp = 0;
int num = 0;
double avrg = 0;
Scanner scanner = new Scanner(System.in);
System.out.println("请输入需要求和与平均数的数字:");
while(scanner.hasNextDouble()) {
temp = scanner.nextDouble();
num++;
sum = sum + temp;
}
avrg = sum / num;
System.out.println("共输入的数字个数为:" + num);
System.out.println(num + "个数字和为:" + sum);
System.out.println(num + "个数字的平均值为:" + avrg);
scanner.close();
}
}
10.反编译
java----class(字节码文件)----反编译(IDEA)
把class文件copy到java文件夹下
11.流程控制
if 语句、switch语句、whil语句、dowhile语句、for循环
package com.ysc.struct;
public class ProcessCtrlDemo {
public static void main(String[] args) {
int i = 0;
int sum = 0;
int esum = 0;
int osum = 0;
System.out.println("=======if--else=======");
if(i == 0){
System.out.println("Init i:" + i);
}else{
System.out.println("Error!");
}
System.out.println("=======while=======");
//for(i = 1; i <= 100; i++){
while(i < 100){
i++;
sum += i;
System.out.println(i);
}
System.out.println("1+2+3+...+100="+sum);
System.out.println("=======do--while=======");
do{
System.out.println(i);
}while(i > 100);
System.out.println("=======for=======");
//计算0-100之间所有奇数和偶数的和
for(int k = 0; k <= 100; k++)
{
//计算0~100所有偶数的和
if((k % 2 ) == 0){
esum += k;
}else { //计算0~100所有奇数的和
osum += k;
}
}
System.out.println("0~100所有偶数的和为:" + esum);
System.out.println("0~100所有奇数的和为:" + osum);
//输出1~1000中能被5整除的数,并且每行输出3个
for (int i1 = 0, j = 0; i1 < 1000; i1++) {
if((i1 % 5) == 0){
if(j < 3){
j++;
System.out.print(i1 + " ");
}else {
j = 0;
System.out.println();
}
}
}
//输出九九乘法表
for (int m = 1; m <= 9; m++) {
for(int n = 1; n <= m; n++){
System.out.print(n + " * " + m + " = " + m * n + "\t");
}
System.out.println();
}
//增强型for循环----jdk5引入,重点是用于数组和集合的
int[] arry = {100, 1000, 10000, 100000, 1000000};
for(int a : arry){
System.out.println(a);
}
//打印101到150之间所有的质数----标签不建议使用
skip:for(int x = 101; x <= 150; x++){
for(i = 2; i < x; i++){
if(x % i == 0){
continue skip;
//break;
}
}
//if(i == x){
//System.out.println(x);
//}
System.out.print(x + "\t");
}
}
}
12.打印三角形
五行的*三角形实现
package com.ysc.struct;
import java.util.Scanner;
public class TriangleDemo {
public static void main(String[] args) {
int i = 0;
int j = 0;
int n = 0;
//默认所有三角形都是n行n列
Scanner scanner = new Scanner(System.in);
System.out.println("请输入三角形的行数:");
n = scanner.nextInt();
//直角三角形,直角在左下边
for(i = 0; i < n; i++){
for(j = 0; j < i + 1; j++){
System.out.print("*");
}
System.out.println();
}
System.out.println();
//直角三角形,直角在右下边
for(i = 0; i < n; i++){
for(j = 0; j < n - 1 - i ; j++){
System.out.print(" ");
}
for(j = 0; j < i + 1; j++){
System.out.print("*");
}
System.out.println();
}
System.out.println();
//直角三角形,直角是在左上边
for(i = 0; i < n; i++){
for(j = 0; j < n - i ; j++){
System.out.print("*");
}
System.out.println();
}
System.out.println();
//直角三角形,直角是在右上边
for(i = 0; i < n; i++){
for(j = 0; j < i ; j++){
System.out.print(" ");
}
for(j = 0; j < n - i; j++){
System.out.print("*");
}
System.out.println();
}
System.out.println();
//角在上边的等边三角形
for(i = 0; i < n; i++){
for(j = 0; j < n - i - 1; j++){
System.out.print(" ");
}
for(j = 0; j < i + 1; j++){
System.out.print("*");
}
for(j = 0; j < i; j++){
System.out.print("*");
}
System.out.println();
}
System.out.println();
//角在下边的等边三角形
for(i = 0; i < n; i++){
for(j = 0; j < i; j++){
System.out.print(" ");
}
for(j = 0; j < n - i; j++){
System.out.print("*");
}
for(j = 0; j < n - i - 1; j++){
System.out.print("*");
}
System.out.println();
}
System.out.println();
}
}
13.方法的重载
方法是语句的集合,他们在一起执行一个功能。
方法是解决一类步骤的有序集合,包含于类或对象中,在程序中被创建,在其他地方被引用。
重载就是在同一个方法中,方法名相同,但形参不同的方法
规则:
1 必须在同一个类中
2 方法名相同
3 方法的参数的个数、顺序或类型不同
4 与方法的修饰符和或返回值没有关系
package com.ysc.method;
public class ReloadDemo {
public static void main(String[] args) {
double sum = 0;
double sum1 = 0;
sum = test(10, 10);
sum1 = test(10.0, 10, 10);
System.out.println("sum="+sum);
System.out.println("sum1="+sum1);
}
public static int test(int a, int b){
System.out.println("test(int, int) -- add");
return a + b;
}
public static double test(double a, int b, int c){
System.out.println("test(double, int, int) -- add");
return (double)(a + b + c);
}
}
14.命令行传参及可变参数
命令行传参
package com.ysc.method;
public class CmdTranPara {
public static void main(String[] args) {
for(int i = 0; i < args.length; i++){
System.out.println("agrs[" + i + "] is " + args[i]);
}
}
}
可变参数
在方法声明中,在指定参数类型后加一个省略号(…)
一个方法中必须只有一个可变参数,任何普通参数必须在它之前进行声明。
package com.ysc.method;
public class VeriablePara {
public static void main(String[] args) {
VeriablePara veriablePara = new VeriablePara();
veriablePara.test(1,2,3,4,5);
printMaxValue(10, 30, 22, 199, 36);
}
public void test(int... i){
System.out.println(i[0]);
System.out.println(i[1]);
System.out.println(i[2]);
System.out.println(i[3]);
System.out.println(i[4]);
}
public static void printMaxValue(double... elements){
if(elements.length == 0){
System.out.println("No members of elements!");
}
double max = elements[0];
System.out.print(elements[0] + " ");
for(int i = 1; i < elements.length; i++){
System.out.print(elements[i] + " ");
if(max < elements[i]){
max = elements[i];
}
}
System.out.println();
System.out.println("the max element of array is " + max);
}
}
15.递归
递归就是方法自己调用自己,利用递归可以用简单的办法来解决复杂的问题,递归的能力在于用有限的语句来定义对象的无限集合。
递归有两个部分:
递归头:什么时候不调用自己。如果没有头,将陷入死循环。
递归体:什么时候需要调用自己。
package com.ysc.method;
import java.util.Scanner;
public class Recursive {
public static void main(String[] args) {
int n;
Scanner scanner = new Scanner(System.in);
System.out.println("请输入需要计算阶乘的数字:");
n = scanner.nextInt();
if(n < 1){
System.out.println("输入错误!");
return;
}
System.out.println(factorial(n));
}
//n! n的阶乘
public static int factorial(int n){
if(n == 1){
return 1;
}else{
return n * factorial(n - 1);
}
}
}
16.数组
数组的四个基本特点:
长度是确定的,数组一旦被创建,它的大小就是不可以改变的。
数组的元素必须是相同类型,不允许出现混合类型。
数组中的元素可以使任何数据类型,包括基本类型和引用类型。
数组变属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。
数组本身就是对象,Java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。
package com.ysc.array;
public class Array {
public static void main(String[] args) {
int i = 0;
//int[] array; //声明
//array = new int[10]; //创建
int[] array = new int[10]; //声明&创建
for(i = 0; i < array.length; i++){
array[i] = i;
System.out.println("array[" + i + "] = " + i);
}
}
}
二维数组、for-each循环
package com.ysc.array;
import java.util.Arrays;
public class SparseArray {
public static void main(String[] args) {
int sum = 0;
int count = 0;
int[][] array = new int[11][11];
array[1][2] = 1;
array[2][3] = 2;
//打印二维数组
printArrays(array);
//转换为稀疏数组保存,并输出
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if(array[i][j] != 0){
sum++;
}
}
}
//创建稀疏数组---行列值
int[][] array1 = new int[sum+1][3];
//打印第一行
array1[0][0] = 11;
array1[0][1] = 11;
array1[0][2] = sum;
//打印剩余行
for (int i = 0; i < array.length; i++) {
//打印每一行
for (int j = 0; j < array[i].length; j++) {
if(array[i][j] != 0){
count++;
array1[count][0] = i;
array1[count][1] = j;
array1[count][2] = array[i][j];
}
}
}
System.out.println("打印稀疏数组");
printArrays(array1);
//创建还原稀疏数组
int[][] backArray = new int[array1[0][0]][array1[0][1]];
for (int i = 1; i < array1.length; i++) {
backArray[array1[i][0]][array1[i][1]] = array1[i][2];
}
//打印还原的稀疏数组
for (int[] ints : backArray) {
for (int anInt : ints) {
System.out.print(anInt + "\t");
}
System.out.println();
}
}
//打印二维数组
public static void printArrays(int[][] arrays){
for (int[] array : arrays) {
for (int i : array) {
System.out.print(i + "\t");
}
System.out.println();
}
}
}
17.面向对象编程
(Object-Oriented Programming)
面向对象及面向过程的意思:
面向过程:
步骤清晰简单,第一步做什么,第二步做什么…
面向对象:
物以类聚,分类的思维模式,思考问题首先会解决问题需要哪些分类,然后对这些问题进行单独思考。最后,在对某个分类下的细节进行面向过程的思索。
面向对象适合处理复杂的问题,适合处理需要多人协作的问题。
面对对象编程的本质就是:以类的方式组织代码,以对象的形式组织数据。
核心思想为抽象
三大特性
封装
继承
多态
对象,是具体的事物。类,是抽象的事物。
从代码运行角度考虑是现有类后有对象,类是对象的模板。
18.属性
19.构造
java中的构造方法是一种特殊的方法,用于初始化对象。java构造函数在对象创建时被调用。它构造值,即提供对象的数据。
构造器:
和类名相同、没有返回值。
作用:
new本质在调用构造方法,初始化对象的值
注意点:
定义有参构造之后,如果想使用无参构造,显示的定义一个无参的构造。
构造函数与普通函数的区别:
- 一般函数是用于定义对象应该具备的功能。而构造函数定义的是,对象在调用功能之前,在建立时,应该具备的一些内容。也就是对象的初始化内容。
- 构造函数是在对象建立时由 jvm 调用, 给对象初始化。一般函数是对象建立后,当对象调用该功能时才会执行。
- 普通函数可以使用对象多次调用,构造函数就在创建对象时调用。
- 构造函数的函数名要与类名一样,而普通的函数只要符合标识符的命名规则即可。
- 构造函数没有返回值类型。
构造函数要注意的细节:
- 当类中没有定义构造函数时,系统会指定给该类加上一个空参数的构造函数。这个是类中默认的构造函数。当类中如果自定义了构造函数,这时默认的构造函数就没有了。备注:可以通过 javap 命令验证。
- (在一个类中可以定义多个构造函数,以进行不同的初始化。多个构造函数存在于类中,是以重载的形式体现的。因为构造函数的名称都相同。
package com.ysc.oop;
public class Application {
public static class Student{
String name;
int age;
//默认构造,无参
public Student(){
this.name = "ysc";
this.age = 1;
System.out.println("this is Student();");
}
//有参构造,重载1
public Student(String name, int age){
this.name = name;
this.age = age;
System.out.println("this is Student(String, int);");
}
//有参构造,重载2
public Student(String name, int age, int num){
this.name = name;
this.age = age;
System.out.println("this is Student(String, int, int);");
}
}
public static void main(String[] args) {
Student student = new Student();
Student student1 = new Student("小老弟",1);
Student student2 = new Student("小老妹",2, 0);
System.out.println("===========================");
System.out.println(student.name);
System.out.println(student.age);
System.out.println("===========================");
System.out.println(student1.name);
System.out.println(student1.age);
System.out.println("===========================");
System.out.println(student2.name);
System.out.println(student2.age);
}
}
20.面对对象的三大特性,封装、继承、多态。
封装
程序设计追求高内聚,低耦合。高内聚就是类的内部数据操作细节自己完成,不允许外部干涉。低耦合就是仅暴露少量的方法给外部使用。
数据的隐藏,通常,应禁止直接访问一个对象中数据的实际表示,而应通过操作接口来访问,这称为信息隐藏。
属性私有,get/set
package com.ysc.oop;
public class Pack {
//属性私有,封装性
private String name;
private int age;
//alt+insert快捷键可以直接打出
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package com.ysc;
import com.ysc.oop.Pack;
public class TestApplication {
public static void main(String[] args) {
int m = 0;
int[][] array = new int[6][6];
System.out.println("=============");
System.out.println("赋值前");
printArray(array);
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
array[i][j] = 6;
}
}
System.out.println("=============");
System.out.println("赋值后");
printArray(array);
//封装性
Pack pack = new Pack();
System.out.println("=============");
System.out.println("初始化态");
System.out.println(pack.getName());
System.out.println(pack.getAge());
System.out.println("=============");
System.out.println("赋值后状态");
pack.setName("ysc");
pack.setAge(100);
System.out.println(pack.getName());
System.out.println(pack.getAge());
}
public static void printArray(int[][] array){
//增强型for循环练习
for (int[] ints : array) {
for (int anInt : ints) {
System.out.print(anInt + "\t");
}
System.out.println();
}
}
}
继承
继承的本质是对某一批类的抽象,从而实现对象是世界的更好的建模。
extends的意思是扩展,子类是父类的扩展。
Java中的类只有单继承,没有多继承。
继承类和类之间是一种关系,除此之外,类和类之间的关系还有依赖,组合、聚合等。
继承关系的两个类,一个为子类(派生类),一个为父类(基类),子类继承父类,使用关键字extends来表示。
子类和父类之间从意义上讲有“is a”的关系。
object类
super
方法重写
package com.ysc.oop;
public class Person {
//父类
public String name = "father";
public int money = 1_0000_0000;
public Person(){
this.name = "little_father_init_Student();";
System.out.println("Person()");
}
//默认构造
public Person(String name){
this.name = "father_init";
}
public void print(){
System.out.println("father print()");
}
}
package com.ysc.oop;
public class Student extends Person {
//子类
public String name;
//super指的是父类的构造函数名
//如果父类定义了有参构造函数,那么父类必须定义显性默认构造函数后,子类才能使用自己的显性默认构造函数
public Student(){
super("haha");
this.name = "little_son_init_Student();";
System.out.println("Student()");
}
public Student(String name){
this.name = "little_son_init_Student(String);";
System.out.println("Student(String()");
}
public void print(){
System.out.println(super.name);
System.out.println(this.name);
System.out.println("son print()");
super.print();
}
}
package com.ysc;
import com.ysc.oop.Student;
public class TestApplication {
public static void main(String[] args) {
Student student = new Student("son1");
student.print();
}
}
super注意点:
- super调用父类的构造方法,必须在构造方法的第一个
- super必须只能出现在子类的方法或者构造方法中
- super和this不能同时调用构造方法
Vs this:
代表的对象不同:
this:本身调用者这个对象
super:只能在继承条件才可以使用
构造方法:
this();本类的构造
super();父类的构造
方法的重写:
重写,需要有继承关系,子类重写父类的方法!
- 方法名必须相同。
- 参数列表必须相同。
- 修饰符:范围可以扩大:
public>protected>Default>private - 抛出的异常:范围,可以被缩小,但不能扩大:ClassNOtFoundException—>exception(大)
重写,子类的方法和父类要一致;
为什么需要重写:
1.父类的功能,子类不一定需要,或者不一定满足!
2.alt + insert:override
package com.ysc.oop;
//重写是方法的重写,和属性无关
public class B {
//父类
//public static void test(){
public void test(){
System.out.println("B->test()");
}
}
package com.ysc.oop;
public class A extends B {
//子类
//public static void test(){
//public void test(){
// System.out.println("A->test()");
//}
@Override //注解:有功能的注释! 重写 alt+insert
public void test() {
System.out.println("A-test()");
}
}
package com.ysc;
import com.ysc.oop.A;
import com.ysc.oop.B;
public class TestApplication {
public static void main(String[] args) {
//静态方法和非静态方法区别很大!
//静态方法:方法的调用只和左边定义的的数据类型有关
//非静态静态方法:重写只和非静态方法有关,且为public修饰
A a = new A();
a.test();
//父类的引用指向子类
B b = new A();
b.test();
}
}
多态