java基础学习第二天

public class HelloWorld{
	public static void main(String[] args){
		int a = 100;
		a = 80;
		int b = 20;
		System.out.println(a+b);
	}
}

注意：变量声明后一定要初始化（赋值），不然报错

存储规则：
文本数据
图片数据
声音数据
视屏数据（图片+声音）
就是数字，字母，符号
在计算机，存的是二进制

加法器

十进制转二进制，16进制，8进制

数据类型
基本数据类型（4类8种）
整数
byte -128~127 1字节
short 2字节
int 4字节
long 8字节

浮点数
float 4字节
double 8字节

字符
char 0~65535 2字节

布尔
boolean 1字节
引用数据类型

public class HelloWorld{
	public static void main(String[] args){
		byte a = 100;
		short b = 20;
		int c = 40;
		long d = 99999999999L; // 后面+L 不然会报错
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
	}
}

public class HelloWorld{
	public static void main(String[] args){
		float a = 10.5F; // 后面+F 不然会报错
		double b = 3.14;
		System.out.println(a);
		System.out.println(b);
	}
}

public class HelloWorld{
	public static void main(String[] args){
		char a = 'a';
		System.out.println(a);
		boolean b = false;
		System.out.println(b);
	}
}

标识符要求
变量名，方法名，类名要见名知意，驼峰写法
数字（不会在首位），字母，下划线，美元符号
不可以是关键字
区分大小写

键盘录入

import java.util.Scanner; // 导包
public class HelloWorld{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in); // 创建对象
		int i = sc.nextInt(); // 接收到的值，给变量
		System.out.println(i);
	}
}

键盘录入，两个数相加

import java.util.Scanner;

public class HelloWorld{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int i = sc.nextInt();
		int j = sc.nextInt();
		System.out.println(i+j);
	}
}

结构
project（项目）
module（模块）
package(包)
class（类）

运算符
算数运算符
+,-,*,/,%

public class HelloWorld{
	public static void main(String[] args){
		int a = 10;
		int b = 12;
		System.out.println(a+b);
		System.out.println(a-b);
		System.out.println(a*b);
		System.out.println(a/b); // 0  不会返回小数
		System.out.println(a%b);
	}
}

代码有小数计算，有可能精确

+的高级使用
数字相加（数据类型不同）
隐式转换（自动类型提升->小变大）
int a = 10;
double b = a;

提升
byte
short
int
long
float
double(最大)

转换为最大的类型来计算
byte,short,char 先转换为 int

强制转换（范围大的变范围小的，人为来做,结果会出错）
格式
目标数据类型 变量名 = （目标数据类型） 被强转的数据;
double a = 123;
int b = (int) a;

字符串相加

public class HelloWorld{
	public static void main(String[] args){
		String a = "10";
		String b = "12";
		System.out.println(a+b);
	}
}

结果"1012"

从左到右，连续执行，类型变化

public class HelloWorld{
	public static void main(String[] args){
		String a = "10";
		int b = 12;
		System.out.println(a+b);
	}
}

结果"1012"，有字符串就变字符串

字符相加（ascII码）

public class HelloWorld{
	public static void main(String[] args){
		int a = 1;
		char b = 'a';
		System.out.println(a+b);
	}
}

结果98

自增自减运算符

public class HelloWorld{
	public static void main(String[] args){
		int a = 1;
		System.out.println(a++);
		System.out.println(a);
		int b = 1;
		System.out.println(++b);
		System.out.println(b);
	}
}

先操作还是先使用
减法同理

赋值运算符

public class HelloWorld{
	public static void main(String[] args){
		int a = 1;
		System.out.println(a);
		int b = 2;
		a += b; // a = a+b;
		System.out.println(a);
		a -= b;
		System.out.println(a);
		a *= b;
		System.out.println(a);
		a /= b;
		System.out.println(a);
		a %= b;
		System.out.println(a);
	}
}

关系运算符（比较运算符）

==
!=
>
>=
<
<=

表达式返回的是布尔型值

逻辑运算符
& 与（并且） 真真为真，其他为假
| 或者 假假为假，其他为真
^ 异或 同为false，不同为true
! 非 取反

短路逻辑运算（具有短路的效果，效率比较高）
&&
||

三元运算符
格式
关系表达式?表达式1:表达式2;

public class HelloWorld{
	public static void main(String[] args){
		int a = 1;
		int b = 2;
		System.out.println(a < b ? a : b); // 它的结果必须要被使用
	}
}

运算符优先级
（）优先所有

表达式

原码反码补码
38集（不会去看）

流程控制语句

顺序结构
从上到下

分支结构
选择

public class HelloWorld{
	public static void main(String[] args){
		int a = 1;
		if (a > 1){
			System.out.print("AAAAAA");
		}else{
			System.out.print("BBBBBB");
		}
	}
}

只有一句的代码，大括号可以不写（最好不要这样）

public class HelloWorld{
	public static void main(String[] args){
		int a = 1;
		if (a == 1)
			System.out.print("AAAAAA");
	}
}

如果对一个布尔类型的变量进行判断，不要用==

public class HelloWorld{
	public static void main(String[] args){
		boolean a = false;
		// if (a == true)
		if (a)
			System.out.print("AAAAAA");
	}
}

直接判断，这样简单
另外不要把==号写成赋值号，那就完了！
格式1

if(){
	
}else{
	
}
格式2
if(){
	
}else if(){
	
}else{
	
}

switch
例子

public class HelloWorld{
	public static void main(String[] args){
		int a = 1;
		switch(a){ // 
			case 0:
			System.out.print(0);
			break;
			case 1:
			System.out.print(1);
			break;
			case 2:
			System.out.print(2);
			break;
			case 3:
			System.out.print(3);
			break;
			default: // 没有执行，进来
			System.out.print("none");
		}
	}
}

循环结构

for

public class HelloWorld{
	public static void main(String[] args){
		for (int i = 0 ; i < 10 ; i++){
			System.out.println(i);
		}
	}
}

while

public class HelloWorld{
	public static void main(String[] args){
		int a =0; 
		while(a < 10){
			a++;
			System.out.println(a);
		}
	}
}

do...while

public class HelloWorld{
	public static void main(String[] args){
		int a =0; 
		do{
			a++;
			System.out.println(a);
		}while(a < 10);
	}
}

数组
长度一般不会改变，不然就去用集合。（集合就可以忽略长度和类型）
容器的类型和存的值类型要一致

格式1
数据类型 [] 数组名
int [] array

格式2
数据类型 数组名[]
int array[]

数组的索引

直接输出数组不行，只能单个输出，或者遍历，直接输出是内存中地址的值（[I@28a418fc 只有28a418fc是地址值16进制）

public class HelloWorld{
	public static void main(String[] args){
		// int [] arr = new int [] {12,23,45,56}; // 声明，初始化，还可以简写（静态的初始化）
		int [] arr = {12,23,45,56};               // 这样
		System.out.println(arr[0]);               // 按索引取值
		System.out.println(arr.length);           // 数组的长度
		int b = arr.length;
		for (int i=0 ; i<b;i++){                 // 数组的遍历
			System.out.println(arr[i]);
		}
	}
}

数组的动态初始化（一开始我不知道）
格式
数据类型[] 数组名 = new 数据类型[数组长度];

public class HelloWorld{
	public static void main(String[] args){
		int[] arr = new int [5]; // 动态声明
		arr[2] = 45; // 赋值，没赋值的是0，因为是整数类型的。
		System.out.println(arr[0]);
		System.out.println(arr.length);
		int b = arr.length;
		for (int i=0 ; i<b;i++){
			System.out.println(arr[i]);
		}
	}
}

如果是浮点数类型，默认值是 0.0
整数类型的默认值是 0
字符 类型，默认值是 ‘/u0000’
布尔 类型，默认值是 false
引用类型 类型，默认值是 null

数组内存图
索引越界，溢出

java内存分配
栈 方法运行的时候，使用的内存
堆 new出来的东西，在堆里（对象，数组等）
方法区（现在叫 元空间 ） 存储可以运行的class文件
本地方法栈 jvm在使用操作系统功能的时候用 和我没关系
寄存器 给cpu使用，和我没关系

方法
程序的最小执行单元
代码打包

public class HelloWorld{
	// main方法开始
	public static void main(String[] args){
		String a = "10";
		String b = "12";
		System.out.println(a+b);
	}
	// 方法结束
}

public class HelloWorld{
	public static void main(String[] args){
		playGame();
		getSum(10,30);
		int data = getData(4,5,8);
		System.out.println(data);
	}

	// 无返回 void
	public static void playGame(){
		System.out.println("play Game!");
	}

	// 传参数
	public static void getSum(int num1,int num2){
		int sum = num1 + num2;
		System.out.println(sum);
	}

	// 有返回，int是返回值的类型
	public static int getData(int num1,int num2, int num3){
		return num1 + num2 + num3;
	}
}

方法的重载
在同一个类中，定义了多个同名的方法，这些同名的方法具有类似的功能。
每个方法具有不同的参数类型或者参数的个数，这些同名的方法，就构成了重载关系。

public class HelloWorld{
	public static void main(String[] args){
		int sum = getSum(12,34,56);
		System.out.println(sum);
	}

	public static int getSum(int num1,int num2){
		return num1+num2;
	}

	public static int getSum(int num1,int num2,int num3){
		return num1+num2+num3;
	}
}

值传递

引用传递（java里好像没有指针一类的知识）

面向对象（思想）

类名 对象名 = new 类名();

这俩文件在同一个包下，当不在同包下，就得引入进来
文件Phone.java

public class Phone{
	// 属性
	String brand; // 属性还有一个修饰符（public 等）
	double price;
	// 行为
	public void call(){
		System.out.println("i calling phone!");
	}

	public void playGame(){
		System.out.println("i doing play game!");
	}
}

文件PhoneTest.java

public class PhoneTest{
	public static void main(String[] args){ // 只有主类才有
		Phone p = new Phone(); // 创建对象
		// 使用属性
		p.brand = "mac";
		p.price = 5499;

		System.out.println(p.brand);
		System.out.println(p.price);
		// 调用方法
		p.call();
		p.playGame();
	}
}

封装
把一个行为集中到一个方法里

private（私有,保证数据的安全性）
只能在本类里使用
set与get方法（针对private，这是通用的，每一个属性都要）
案例

文件Phone.java

public class Phone{

	private String brand; // 私有属性
	private double price;

	public void call(){
		System.out.println("i calling phone!");
	}

	public void playGame(){
		System.out.println("i doing play game!");
	}
	// 对属性赋值
	public void setBrand( String b){
		brand = b;
	}
	// 获取属性值
	public String getBrand(){
		return brand;
	}

	public void setPrice( double p){
		price = p;
	}

	public double getPrice(){
		return price;
	}
}

文件PhoneTest.java

public class PhoneTest{
	public static void main(String[] args){
		Phone p = new Phone();
		// 对于私有属性的赋值
		p.setBrand("mac");
		p.setPrice(5499);

		System.out.println(p.getBrand()); // 私有属性的取值
		System.out.println(p.getPrice());

		p.call();
		p.playGame();
	}
}

this关键字
成员变量（类里的属性）
局部变量（方法里的变量）
它俩同名，傻傻分不清楚
就近原则（谁离我近，用谁，局部变量会被使用，但是离开了方法，一般就会出问题）

案例 Phone.java

public class Phone{

	private String brand;
	private double price;

	public void call(){
		System.out.println("i calling phone!");
	}

	public void playGame(){
		System.out.println("i doing play game!");
	}

	public void setBrand( String brand){
		// brand = brand; // 这里就会报错
		this.brand = brand; // 使用this来区分成员变量和局部变量
	}

	public String getBrand(){
		return brand;
	}

	public void setPrice( double p){
		price = p;
	}

	public double getPrice(){
		return price;
	}
}

文件 PhoneTest.java

public class PhoneTest{
	public static void main(String[] args){
		Phone p = new Phone();

		p.setBrand("mac");
		p.setPrice(5499);

		System.out.println(p.getBrand());
		System.out.println(p.getPrice());

		p.call();
		p.playGame();
	}
}

构造方法
创建对象的时候给成员变量赋值（自动的，不用调用setXXX方法，我们不写，jvm他自己能写，是一个默认无参的构造方法，不过，自己可以写出来）
例子

文件PhoneTest.java

public class PhoneTest{
	public static void main(String[] args){
		// Phone p = new Phone(); // 这里就开始自动调用构造函数
		Phone p = new Phone("mac",5499); // 里面放值

		System.out.println(p.getBrand());
		System.out.println(p.getPrice());
	}
}

文件Phone.java

public class Phone{

	private String brand;
	private double price;

	// 测试构造函数，自己跑没跑
	// public Phone(){
	// 	System.out.println("gouzaohanshu");
	// }

	// 我自己写的构造函数，里面实现了可以赋值的功能
	public Phone(String brand,double price){
		this.brand = brand;
		this.price = price;
	}

	public String getBrand(){
		return brand;
	}

	public double getPrice(){
		return price;
	}
}

对象的内存图
垃圾回收机制

静态 static
共享属性，赋值一次，类里面都可以使用

静态属性

文件 Student.java

public class Student{
	String name;
	int age;
	static String teacherName; // 静态
	public void show(){
		System.out.println(name+age+teacherName);
	}
}

文件UseStudent.java

public class UseStudent{
	public static void main(String[] args){
		Student.teacherName = "fei tracher"; // 调用静态
		Student s1 = new Student();
		s1.name = "Lilly";
		s1.age = 15;
		s1.show();

		Student s2 = new Student();
		s2.show();
	}
}

静态方法
多用于工具类，本类直接写方法名，其他类用类名来调用
静态方法里没有this

多态（同种类型，多种表示）
继承是多态的前提
多种形态
作用：
子类可以是多种多样的{
父类：人
子类：学生，老师，辅导员
}
表现{
父类类型 对象名称 = 子类的对象;
}
前提{
有继承关系
有父类引用指向子类的对象
有方法重写
}

继承
父的东西，子来用
java只支持单继承，不支持多继承（但是可以层层继承）

例子继承的思路
动物{
猫{
布偶猫
}
狗
}

包

final 最终的，不可以被改变的{
方法
类
变量
}

文件 Animal.java

public class Animal{
	public void eat(){
		System.out.println("is eating!");
	}

	public void dirnk(){
		System.out.println("is dreaking!");
	}
}

文件 Cat.java

public class Cat extends Animal{ // 继承
	public void catchMouse(){
		System.out.println("cat is catching mouse!");
	}
}

文件 Dog.java

public class Dog extends Animal{
	public void lookHome(){
		System.out.println("dog is looking Home!");
	}
}

文件 Ragdoll.java

public class Ragdoll extends Cat{ // 一个空类
}

文件Test.java

public class Test{
	public static void main(String[] args){
		Ragdoll rd = new Ragdoll();
		rd.eat();
		rd.dirnk(); // 父类的父类
		rd.catchMouse(); // 父类的

		Dog dog = new Dog();
		dog.eat();
		dog.dirnk();
		dog.lookHome();
	}
}

注意：
子类只可以访问非私有的成员（private）

子类能继承父类的什么？
类成员{
构造方法（私有不能继承）
成员变量（都能继承）
成员方法（私有不能继承）
}

继承的特点{
成员变量：就近原则
}

子类使用父类{
例如变量叫name
name就是局部的位置开始找
this.name就是本类的成员位置开始找
super.name从父类的成员位置开始找
}

重写（虚方法表被覆盖）{
父类的方法不满足子类的要求，子类就可以重写这个方法上面注释// @ 这个是解释重写的
重写是方法名相同，参数们要一致，但是功能不相同
访问权限要大于等于父类的权限
返回值的类型必须要小于父类的返回值
私有，静态的方法不可以被重写
}

权限修饰符{
private 同一个类里访问
空着不写 同一个包里访问
protected 不同包下的子类
public 都可以调用
}
权限依次变大
控制的成员能被访问的范围
可以修饰变量，方法，构造方法，内部类

抽象{
public abstract class 类名
不写方法体
抽象不可以创造对象
抽象类不一定有抽象方法，但抽象方法的类一定是抽象类
都得实重现里面的抽象方法
}

字符串（引用类型，参照手册）
字符串拼接
比较
替换
拼接
查找
切割
检索
加密
大小写替换
等

字符串的内容是不可以改变的，只能赋值给新的变量

public class HelloWorld{
	public static void main(String[] args){
		String name = "qqw";
		name = "123"; // 换了新的值，一个新变量地址赋值给了name变量
		System.out.println(name);
	}
}

java的对比，是不是“”或者是不是null有特殊的方式（千万不要用 ==）
基本数据类型比较数据值
引用类型比较值的地址（和对象特别像）

字符串比较内容用quuals或者equalsIgnoreCase（忽略大小写）方法
例子

public class HelloWorld{
	public static void main(String[] args){
		String name = "qqw";
		String name2= "4568";
		System.out.println(name == name2); // 比较字符串的地址
		if(name.equals(name2)){ // 比较字符串的内容
			System.out.println("is ok");
		}else{
			System.out.println("is not ok");
		}

		if(name.equalsIgnoreCase(name2)){
			System.out.println("is ok");
		}else{
			System.out.println("is not ok");
		}
	}
}

StringBuilder，可以看作是一个容器，创建之后，里面的内容是可以修改的
这个比String好用
它里面还有很多方法
例子

public class HelloWorld{
	public static void main(String[] args){
		StringBuilder sb = new StringBuilder();
		System.out.println(sb); // 这里不是地址，而是一个属性值
	}
}

public class HelloWorld{
	public static void main(String[] args){
		StringBuilder sb = new StringBuilder("456");
		// System.out.println(sb);

		sb.append(1); // 字符串添加，拼接
		sb.append(1.5);
		sb.append(true);
		sb.append("741");
		System.out.println(sb);
	}
}

public class HelloWorld{
	public static void main(String[] args){
		StringBuilder sb = new StringBuilder("456");
		// System.out.println(sb);
		sb.append(1);
		sb.append(1.5);
		sb.append(true);
		sb.append("741");
		System.out.println(sb);

		sb.reverse(); // 字符串反转
		System.out.println(sb);
	}
}

public class HelloWorld{
	public static void main(String[] args){
		StringBuilder sb = new StringBuilder("456");
		// System.out.println(sb);

		sb.append(1);
		sb.append(1.5);
		sb.append(true);
		sb.append("741");
		System.out.println(sb);

		sb.reverse();
		System.out.println(sb);

		int num = sb.length(); // 获取字符串长度
		System.out.println(num);	
	}
}

public class HelloWorld{
	public static void main(String[] args){
		StringBuilder sb = new StringBuilder("456");
		// System.out.println(sb);

		sb.append(1);
		sb.append(1.5);
		sb.append(true);
		sb.append("741");
		System.out.println(sb);

		sb.reverse();
		System.out.println(sb);

		int num = sb.length();
		System.out.println(num);
		// sb是一个对象，需要转回字符串，用它，toString
		String str = sb.toString();
		System.out.println(str); // 字符串类型
	}
}

链式编程（一串方法）

stringJoiner(拼接更高效)
例子
成员方法
add()
length()
toString()

import java.util.StringJoiner; // 要记得引入
public class HelloWorld{
	public static void main(String[] args){
		StringJoiner sj = new StringJoiner("---"); // 中间间隔的符号
		sj.add("41").add("jaja"); // 只能添加字符串，不可以用其他的类型
		System.out.println(sj);
	}
}

import java.util.StringJoiner;
public class HelloWorld{
	public static void main(String[] args){
		StringJoiner sj = new StringJoiner("---");
		sj.add("41").add("jaja");
		System.out.println(sj);

		StringJoiner sj2 = new StringJoiner("---","[[","]]"); // 参数的意思，间隔，首部，尾部
		sj2.add("41").add("jaja");
		System.out.println(sj2);
	}
}

import java.util.StringJoiner;
public class HelloWorld{
	public static void main(String[] args){
		StringJoiner sj = new StringJoiner("---");
		sj.add("41").add("jaja");
		System.out.println(sj);

		StringJoiner sj2 = new StringJoiner("---","[[","]]");
		sj2.add("41").add("jaja");
		System.out.println(sj2);

		System.out.println(sj2.length()); // 获取长度
		System.out.println(sj2.toString()); // 转换为字符串
	}
}

new不会复用，直接开辟空间

字符串扩容，添加

ArrayList 集合（数组单一类型，混数据的时候不方便，扩容的时候也不方便）
只可以存储引用类型
存储基本数据类型，先变成包装类
泛型（限定集合中数据类型）

增
add()
删
remove()
改
set()
查
get()

size()

案例

import java.util.ArrayList;
public class HelloWorld{
	public static void main(String[] args){
		ArrayList<String> list = new ArrayList<>();
		list.add("aaa"); // 添加
		list.add("bbb");
		list.add("CCC");

		list.remove("aaa"); // 返回布尔值
		list.remove(1); // 返回该元素，他们的索引是变化的，删后，他们的索引变化了
		System.out.println(list);
	}
}

import java.util.ArrayList;
public class HelloWorld{
	public static void main(String[] args){
		ArrayList<String> list = new ArrayList<>();
		list.add("aaa");
		list.add("bbb");
		list.add("CCC");

		String a = list.set(1,"fei"); // 修改，返回这个元素，参数：索引，新的值

		System.out.println(list);
		System.out.println(a);
	}
}

import java.util.ArrayList;
public class HelloWorld{
	public static void main(String[] args){
		ArrayList<String> list = new ArrayList<>();// 泛型，把集合控制数据类型
		list.add("aaa");
		list.add("bbb");
		list.add("CCC");

		String a = list.get(0); // 查询
		int num = list.size(); // 获取长度（配合循环就可以遍历）
		System.out.println(list);
		System.out.println(a);
		System.out.println(num);
	}
}