java基础知识学习

#### 一、java程序入口：

1、

```java
public class Demo1{
public static void main(String[] args){
System.out.println("hello");
}
}
```

2、保存的文件必须和类名相同即为：Demo1.java
3、编译javac Demo1.java 会生成相应的字节码文件Demo1.class
4、运行java Demo1 注意不用加.class

#### 二、数据类型

1、基本类型
1.1 整数类型：byte(1) short(2) int(4) long(8)

1.2 浮点类型: float(4) double(8)

1.3 布尔类型：boolean(1)

1.4 字符：char(2)

2、引用类型

字符串数组类接口 lamba

*1、字符串不是基本数据而是引用类型*

*2、浮点数据默认类型是double 如果一定要使用float 则需要加一个后缀f*

*3、整数数据默认类型是如果一定要使用long则需要加一个后缀L*

#### 三、变量的定义

1、变量类型变量名=变量值

2、定义一个变量时必须赋值，否则无法使用

3、定义整数和浮点类型的变量其值不能超过其类型范围

4、定义float和long类型的变量时其值后面要加F和L

5、自动类型转换：将小范围的数据类型自动转换为大范围的数据类型如：long num1=12;//12默认是int类型

6、强制类型转换：将大范围的数据类型(没有超过小范围类型的数据)强制转换为小范围的数据类型如：int num1=(int)12L;//12是long类型

7、byte/short/char 这三种类型可以发生运算，并且也可以互相赋值，都首先会提升为int类型，然后运算（其结果变量类型为int)

```java
public class Demo1 {
public static void main(String[] args) {
byte b1='A';
b1+=10;//此处b1=b1+10 本来结果是int但编译器会自动强转不需手动转换
byte b2=10;
byte b3=b1+b2;//此处需要强转byte b3=(byte)(b1+b2);
long ll=10L;
int aa=ll;//此处会报错需手动强制转换 int aa=(int)ll;

}
}

```

#### 四、运算符

加+减_乘*除/求余% ++ --

```java
public class Demo1 {
public static void main(String[] args) {
byte b1='A';
short s1='中';
char c1=65;
System.out.println(b1);//65
System.out.println(b1++);//65
b1++;
System.out.println(b1);//67
System.out.println("aa"+12+12);
}
}
```

#### 5、条件循环控制语句

switch 条件类型只能是byte short int char这四种基本数据类型和String enum这两种引用类型

```
public class Demo1 {
public static void main(String[] args) {
int num=2;
switch(num){
case 1:
System.out.println("11111");
break;
case 2:
System.out.println("22222");
//break;
case 3:
System.out.println("33333");
break;
default:
System.out.println("default");
break;
}
}
}
//若case中没有break则代码运行直到遇见break退出switch 结果22222 33333
```

#### 6、Idea快捷键

ctrl+y 删除当前行

ctrl+d 复制当前行

ctrl+alt+l 代码格式化

alt+/ 自动导入

ctrl+/ 注释

ctrl+shift+/ 注释多行

alt+insert 自动生成代码

alt+shift+上下前头移动代码

#### 7、方法

方法重载：方法名相同参数列表不同（参数个数参数类型参数顺序不同）注：与参数名称和返回值无关

#### 8、数组

数组初始化：动态初始化：1、String[] strArr=new String[4];//必须指定长度 2、String[] strArr1=new String[]{"aa","bb"};//不需指定长度

静态初始化：String[] strArr2={"aa","cc","ee"}

#### 9、java内存划分

1、栈(stack)：存放的都是方法的局部变量（方法的参数，方法{}的内部变量一旦超出作用域，立刻从栈内存消失）

2、堆(Heap):凡是new出来的东西，都在堆当中，堆内存里面的东西都有一个地址：16进制

堆内存里面的数据，都有默认值规则：整数：默认为0 浮点：默认为0.0 字符默认为'\u0000' 在，布尔默认为false 引用类型：默认为null

3、方法区（method area):存储.class相关信息，包含方法的信息

4、本地方法栈（native method stack)：与操作系统相关；

5、寄存器(pc register):与cpu相关

#### 10、成员变量和局部变量

局部变量：在方法内，没有默认值，必须赋值才可以使用，作用域方法内，在栈内存随着方法进栈而诞生随着方法出栈而消失

成员变量：在类中，有默认值，作用域整个类内在堆内存随着对象创建而诞生随着对象回收而消失

#### 11、类

封装继承多态

成员变量private 通过get set方法可以访问并且进行相应的限制其中boolen类型的成员变量 get是is

在类中当方法局部变量和成员变量重名时，最近原则会使用局部变量，若要使用成员变量在前加this.

一个java标准类：所有成员变量private 一个无参的构造函数一个全参的构造函数成员变量的get set方法

类静态方法和静态成员变量最好用类名访问，类静态方法只能访问类静态成员变量，并且内部不能用this，类的一般方法即可以访问成员变量也可以访问静态成员变量和调用静态方法

#### 12、ArrayList

ArrayList<E> strList=new ArrayList<>();//jdk1.7以上右边的泛型类型可以不写

E是泛型类型必须是引用类型（byte->Byte，short->Short，int->Integer，long->Long，float->Float，double->Double，char->Character，boolean->Boolean) ArrayList<Integer> strList=new ArrayList<>();

#### 13、类和接口

```
public class Father {
int numF=40;
int num=10;
public void fun(){
System.out.println(num);
}
public void funF(){
System.out.println(num);
}
}
public class Son extends Father {
int numS=50;
int num=30;
public void fun(){
System.out.println(num);
}
public void funS(){
System.out.println(num);
}
}
public static void main(String[] args) {
/*
* 直接通过子类对象访问成员变量：
* 等号左边是谁，就优先用谁的成员变量，若没有则向父类找
* 间接通过成员方法访问成员变量：
* 该方法属于谁，就优先用谁的成员变量，若没有则向父类找
*
* 直接通过子类对象访问成员方法：
* 等号右边对象是谁，就优先用谁的成员方法，若没有则向父类找
* 子类访问父类的成员变量和成员方法用super
* */
Father father = new Father();
System.out.println(father.num);//10
father.fun();
Father son = new Son();
System.out.println(son.num);//10
son.fun();//30
Son son1 = new Son();
System.out.println(son1.num);//30
son1.fun();//30
son1.funF();;//10
}
}
```

方法重写：1、子类与父类的方法名称参数列表相同，

2、子类的方法返回值类型可以小于父类返回值类型

3、子类的方法的访问权限修饰符必须大于等于父类方法的访问权限修饰符（public>protected>default>private)

构造函数：子类的构造函数中个默认会首先调用父类的构造函数，子类构造函数可以通过super调用父类的构造函数，并且super要用于第一行语句

抽象类：可以抽象方法（无方法体{}）也可以有非抽象方法（有方法体{...}）,抽象类不能new,但可以有构造函数（子类的构造函数中个默认会首先调用父类的无参构造函数），子类继承抽象类必须实现父类的抽象方法（除非该类也是抽象类）

接口：jdk7.0 可有常量抽象方法 jdk8.0 可有默认方法静态方法 jdk9 私有方法（默认修饰符都是public abstract所以可以省略不写）接口不能new ,子类实现接口必须实现接口的所有抽象方法（除非该类也是抽象类）

类与类是单继承的一个类只能同时继承一个父类

类与接口是多实现，一个类可以同时实现多个接口

接口与接口是多继承，一个接口可以继承多个接口（多个父接口的抽象方法可以重复，但多个父接口的默认方法重复时，子接口必须重写这个默认方法）

final 可以修饰类成员局部变量成员方法，final 修饰类则该类不可以有子类修饰成员方法则该方法不可以被重写修饰成员变量：由于成员变量有默认值，所有使用final修饰时必须指定成员的值，

#### 14、装箱拆箱

装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型

#### 15、集合

![](C:\Users\howhy\AppData\Roaming\Typora\typora-user-images\image-20201105162156292.png)

set不允许重复的原理：hash(一个十进制数据)表：数组+链表/数组+红黑树（数组存hash值链表存对象）

```
public class Demo1 {
public static void main(String[] args) {
HashSet<String> objects = new HashSet<>();
String str1=new String("abc");
String str2=new String("abc");
objects.add(str1);//先调用String的hashCode看hash表数组中有否有相同的hash值若有然后再用Equals与链表中的对象的比较看是否有相同的若有则重复不放入链表中否则不重复放于
objects.add(str2);
System.out.println(objects);
}
}
```

#### 16、泛型

```
public class Person<T> {
private T name;

public Person() {
}

public Person(T name) {
this.name = name;
}

public T getName() {
return name;
}

public void setName(T name) {
this.name = name;
}

public <E> void hello(E e){//泛型方法定义：访问修饰符泛型定义<T> 方法返回类型方法名(方法参数就可以使用定义的泛型了 T t)
System.out.println(e);;
}

public <E> String hello1(E e){
return String.valueOf(e);
}

public static <E> void hello2(E e){
System.out.println(e);
}
}
```

#### 17、map

k不允许重复 v可以重复

put(k,v)//若有重复的k了，则返回原覆盖的k的值否则返回null

remove(k)//若map有相应的k则返回相应的值v否则没有k返回null

get(k)//若map有相应的k则返回相应的值v否则返回null

#### 18、Throwable

Exception extends Throwable

编译期异常和运行期异常的区别

（1）Java中的异常被分为两大类：编译时异常和运行时异常。
（2）所有的RuntimeException类及其子类的实例被称为运行时异常，其他的异常就是编译时异常。

编译时异常

Java程序必须显示处理，否则程序就会发生错误，无法通过编译。

运行时异常

无需显示处理，也可以和编译时异常一样处理。

注：如果finally有return语句，则永远返回finally中的结果，避免这样使用

#### 19、线程

Thread implements Runnable

```
SayThread sayThread = new SayThread("aaa");//定义一个类继承Thread并覆盖run方法
sayThread.start();

new Thread(){//匿名类并覆盖run方法
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"aaa");
}
}.start();
new Thread(new Runnable() {//定义一个类实现Runnbale（或匿名类）接口并实现run方法，然后new Thread并start 此方法是最好业务实现和线程启动分开了
@Override
public void run() {
System.out.println("ssssssssssss");
}
}).start();
```

#### 20、接口函数lamba

若一个接口中只有一个抽象方法，并且该接口是一方法的形参，则可以用lamba表达式的方式

```java
package com.howh.doudizhu;

public interface PringLogInterface {
public abstract void pp(String msg);
}
package com.howh.doudizhu;

public class Demo {
public static void main(String[] args) {
pringLog((msg)->{
System.out.println(msg);//"aaaaa"
},"aaaaa");
}

public static void pringLog(PringLogInterface plog,String msg){
plog.pp(msg);
}
}
```

#### 21、反射

Class clazz=Class.forName("com.howh.doudizhu.Person");

clazz=Person.class;

clazz=new Person().getClass();

```java
package com.howh.doudizhu;

public class Person {
private String name;
private String age;
public String a;
protected String b;
String c;
public Person() {
}

public Person(String name, String age) {
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

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

public String getAge() {
return age;
}

public void setAge(String age) {
this.age = age;
}
public void sleep(){
System.out.println(this.name+" sleep");
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age='" + age + '\'' +
", a='" + a + '\'' +
", b='" + b + '\'' +
", c='" + c + '\'' +
'}';
}
}

package com.howh.doudizhu;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Demo {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, InstantiationException {
Class personClass=Person.class;
Field[] fileds=personClass.getFields();//获取类的public修饰的成员属性
for (Field filed : fileds) {
System.out.println(filed);//public java.lang.String com.howh.doudizhu.Person.a
}
Field field=personClass.getField("a");//获取类的public修饰的特定的成员属性
Person per=new Person();
System.out.println(field.get(per));//获取成员属性a的默认值为 null
field.set(per,"aaaa");//获取成员属性a的值为aaaa
System.out.println(field.get(per));//获取成员属性a的默认值为 aaaa
fileds=personClass.getDeclaredFields();//获取类的所有的成员属性
for (Field filed : fileds) {
System.out.println(filed);
}
field=personClass.getDeclaredField("name");
field.setAccessible(true);//设置private 成员属性忽略访问修饰符
System.out.println(field.get(per));// 若不设置field.setAccessible(true)报错因为name是private null

Constructor constructor=personClass.getConstructor(String.class,String.class);//两个参数的person构造方法
Object object=constructor.newInstance("zhangsan","23");
System.out.println(object);//Person{name='zhangsan', age='23', a='null', b='null', c='null'}
personClass.newInstance();//person无参的构造方法

Method method=personClass.getMethod("sleep");
per=new Person("lisi","44");
method.invoke(per,null);//lisi sleep
}
}

package com.howh.doudizhu;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

public class ReflectTools {
public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Properties properties=new Properties();
ClassLoader classLoader = ReflectTools.class.getClassLoader();
InputStream resourceAsStream = classLoader.getResourceAsStream("pro.properties");
properties.load(resourceAsStream);
String className=properties.getProperty("className");
String methodName=properties.getProperty("methodName");
Class<?> aClass = Class.forName(className);
Object o = aClass.newInstance();
Method sleep = aClass.getMethod("sleep");
sleep.invoke(o);
}
}

```

#### 22.注解

```
package com.howh.doudizhu;

import java.lang.annotation.ElementType;
import java.lang.annotation.Target;

@Target(value = {ElementType.TYPE})//表示此注解只能用于类上
public @interface MyAnno {
int age();
String name();//属性常用类型 String Enum Array
/*
* 元注解：@Target 注解作用的位置
* @Retention:描述注解被保留的阶段
* @Documented:描述注解是否被抽取到api文档中
* @Inherited:描述注解是否被子类继承
*
* */
}

package com.howh.doudizhu;
@MyAnno(age=23,name = "howhy")
public class Demo2 {

}
```

posted @ 2021-07-15 09:51 howhy 阅读(58) 评论(0) 收藏举报

刷新页面返回顶部

Howhy Blogs

java基础知识学习

公告