本文主要是介绍JavaSE(写一些关于自己学习中觉得可能会记不清的东西。大概只适合自用），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

JAVA01

public class Demon01{
  static string name;//加static可以在下面直接用
  int age;//这需要用new
    public static void main(String [] args){
    Demon01 demon01=new Demon01();
      System.out.println(demon01.age);
      System.out.println(name);
    
  }
}

常量：

final 常量名 = 值；

final pi =3.14；

static final double PI=3.14;

final static double PI=3.14;相同，前面属于修饰符不区分前后

变量命名规则：

所有变量，方法，类名：见名知意；

类成员变量：首字母小写和驼峰原则：monthSalay。

局部变量：同上

常量：全部大写和下划线：MAX_VALUE

类名：首字母大写和驼峰

方法名：小驼峰

JAVADoc

/**

*/

@author

@version

@since 指明需要最早的JDK版本

@param参数

@return

@throws抛出的异常

Scanner

new Scanner(System.in)

Scanner scanner =new Scanner(System.in);

System.out.println(“使用next.line方式接收：”)；

String str =scanner.nextLine()

scanner.close();

JAVA方法

重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数

重载的规则：

• 方法名称必须相同。
• 参数列表必须不同（个数不同，或者类型不同，参数的排列顺序不同等）
• 方法的返回类型可以 相同也可以不同
• 仅仅返回类型不同不足以成为方法 的重载

实现理论：方法名称相同时，编译器会根据调用方法的参数个数，参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，编译器报错

可变参数

JDK1.5开始，JAVA支持传递同类型的可变参数给一个方法。

在方法声明中，在指定参数类型后加一个省略号（…)

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何普通的参数必须在它的声明之前。

public static void printMax(double...numbers){
  if (numbers.length == 0){
    System.out.println("NO argument passed");
    return;
  }
  double result = numbers[0];
  for (int i = 1;i < numbers.length;i++){
    if (numbers[i] > result){
      result =numbers[i];
    }
  }
  System.out.println("The max Vaule is" + result);
}

递归

递归要包含两个部分：

• 递归头：什么时候不调用自身方法，如果没有头，递归将陷入死循环
• 递归体：调用自身的时候

数组

数组的声明与创建；

dataType [] arrayRefVar;
dataType arrayRefVar[];
//Java 语言使用new操作符来创建数组：
dataType[] arrayRefVar = new dataType[arraySize];

Java内存–1堆：*存放new的对象和数组

​ *可以被所有的线程共享，不会存放别的对象引用

​ --2栈：*存放基本变量类型（会包含这个基本类型的具体数值）

​ *引用对象的变量（会存放这个引用在堆里的具体位置）

​ --3方法区：*可以被所有的线程共享

​ *包含了所有的class和static变量

System.out.println(Arrays.toString(a));//输出a这个数组的所有值用中括号括起。

JAVA面向对象

面向对象编程（oop）

面向对象编程的本质就是：以类的方式组织代码，以对象的方式组织（封装）数据

三大特性：封装，继承，多态。。

static

有static可直接调用

如果修饰中没有static，就需要实例化这个类用new：如：

public class Demon02{
  public static void main(String[] args){
    Student student = new Student();
    student.say();
  }
}

public class Student{
  public void say(){
		System.out.println("说话")；
  }
}

构造器

一个类即使什么都不写，它也会存在一个方法。即构造方法。

构造器也称构造方法；是创建对象的时候必须要调用的，并且构造器有以下两个特点：

• 必须和类的名字相同
• 必须没有返回类型，也不能写void

public class Person{
	String name;
	//无参构造
	public Person(){
		this.name="cqi";//初始化值
	//有惨构造
	public Person(String name){
		this.name = name;
	}
	}
}

public class Application{
  public static void main(String[] args){
    Person person =new Person();
    Person person = new Person("cqi");//有参
  }
}

command+n

面向对象（封装）

public class Student{
  //属性私有
  private String name;
  private int id;
  private char sex;
  public String getName(){
		return this.name;
  }
  
  public String setName(String name){
    this.name=name;
  }
}

public class Application{
  public static void main(String[] args){
    Student s1 =new Student();
    s1.name=.     //这是错的，不能调用
      
    s1.setName("cqi");
    System.out.println(s1.getNmae());
  }
}

继承

JAVA中类只有单继承，没有多继承。

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模

extends的意思是“拓展”。子类是父类的拓展。

继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖，组合，聚合等。

继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键词extends来表示

object类

super类

方法重写

public class Person{
  private age = 10;
  
  public int money=10000000; 
  public void say(){
    System.out.println("说化")；
  }
  public int getAge(){
    return age;
  }
  public void setAge(int age){
    this.age=age;
  }
  
}

//学生  is  人
public class Student extends Person{
  
}

​

public class Teacher extends Person{
  
}

public class Application{
  public static void main(String[] args){
		Student student =new Student();
    student.say();
    System.out.println(student.money);
    student.age;//这是错的
    student.getAge();
  }
}

不能继承父类私有的属性。

super

public class Person{
  protect String name = "zhyi";
  
}

public class Student extends Person{
  private String name ="cqi";
  public void test(String name){
		System.out.println(name);//指传入test方法中的名字
    System.out.println(this.name);//指学生类中的name
    System.out.println(super.name);//指Person类中的name
    
  }
}

public class Application{
  public static void main(String[] args){
    Student student = new Student();
    student.test("hu");
		
  }
}

输出结果为：
  hu
  cqi
  zhyi
  
  

父类构造器在子类的上面

super注意点：

1.super调用父类构造方法，必须在构造器的第一个

2.super只能出现在子类的方法或构造方法中

3.super和this不能同时调用构造方法

this：本身调用者这个对象

super必须在继承条件下才能使用

方法重写

重写都是方法的重写，和属性无关

public class Application{
  public static void main(String[] args){
    A a =new A();
    a.test;
    B b =new A();
    b.test
  }
}

public class A extends B{
  public static void test(){
    System.out.println("A->text");
  }
}

public class B {
  public static void test(){
    System.out.println("B->text");
  }
}

输出为

A-〉text

B->text

public class A extends B{
  public void test(){
    System.out.println("A->text");
  }
}

public class B {
  public void test(){
    System.out.println("B->text");//子类重写了父类的方法
  }
}

输出为：

A->text

A->text

这个为重写

重写只和非静态有关

静态的方法和非静态的方法区别很大

静态方法方法的调用只和左边的定义有关

重写：需要有继承关系，子类重写父类的方法

1方法名必须相同

2参数列表必须相同

3修饰符：范围可以扩大： public>protected>Default>private

4抛出的异常，范围：可以被缩小，但不能扩大。

重写，子类的方法和父类必须一致，方法体不同

为什么要重写：

1.父类的功能，子类不一定需要，或者不满足

多态

public class Student extends Person{
  public void run(){
    System.out.println("son")；
      
      
  }
  public void eat(){
     System.out.println("eat")；
  }
  
}

public class Person{
  public void run(){
    System.out.println("run")
  }
}

public class Appliction{
  public static void main(String[] args){
    //一个对象的实际类型是确定的
    //new Student();
    //new Person();
    //指向的引用类型就不确定了，父类的引用指向子类
    Student s1 =new Student();
    Person s2 =new Student();
    s2.run();
    s1.run();
    s2.eat();//错误，不能调用
    s1.eat();
  }
}

结果：son

​ son

对象能执行哪些方法，主要看对象左边的类型，和右边关系不大

//Student能调用的方法是自己的和继承父类的

//Person可以指向子类，但不能调用子类私有的方法

((Student)s2).eat();强制类型转换可以调用了

多态的注意事项：

1，多态是方法的多态，属性没有多态

2，父类和子类有关系。类型转换异常：ClassCastException

3存在条件：继承关系，方法需要重写，父类引用指向子类对象！

1.static 方法属于类，它不属于实例

2final常量

3private

—这三种不能重写

instanceof

public class Person{
  
}

public class Student extends Person{
  
}

public class Teacher extends Person{
  
}

public class Application{
  public static void main(String[] args){
    //Object>Person>Student
    Object object = new Student();
    System.out.println(object instanceof Student);
    System.out.println(object instanceof Object);
    System.out.println(object instanceof Person);
    System.out.println(object instanceof Teacher);
    System.out.println(object instanceof String);
    
    Person person =new Student();
    System.out.println(person instanceof Student);
    System.out.println(person instanceof Object);
    System.out.println(person instanceof Person);
    System.out.println(person instanceof Teacher);
    //System.out.println(person instanceof String);//编译就出错
    
    
    
   Student student =new student();
    System.out.println(student instanceof Student);
    System.out.println(student instanceof Object);
    System.out.println(student instanceof Person);
   // System.out.println(student instanceof Teacher);编译出错
    //System.out.println(student instanceof String);//编译就出错
    
  }
}

结果：True

​ True

​ True

​ False

​ False

true

true

true

false

true

true

true

高 低

Person student= new Student()

低转高不需要强制转换

但这个student无法使用Student类中的方法，需要强制转换成Student类型。

高转低：

Student student1=（Student） student；

student1可以使用Student类中方法

子类转换为父类可能丢失一些方法

static

public class Person{
  {
    System.out.println("匿名代码块")；//可以用于赋初始值
  }
  static{
    System.out.println("静态代码块")；//只执行一次
  }
  public Person(){
    System.out.println("构造方法")；
  }
  public static void main(String[] args){
    Person person1 = new Person();
    Person person2 = new Person();
  }
}

输出：静态代码块

​ 匿名代码块

​ 构造方法

​ 匿名代码块

​ 构造方法

抽象类

//abstract 抽象类
public abstract class Action{
	//约束。有人帮我们实现
  //abstract，抽象方法，只有方法的名字，没有方法的实现
  
  public abstract void doSomething();
}

//子类继承抽象类，子类需要完成方法的实现
public class A extends Action{
  public void doSomething(){
    
  }
  
}

抽象类不能new出来，只能靠子类去实现它：约束！

抽象类可以写普通方法。

接口

接口：只有规范！自己无法写方法，专业的约束！：约束和实现分离：面向接口编程

普通类；只有具体实现

抽象类：具体实现和规范（抽象方法）都有

声明类的关键词是class，声明接口的关键词是interface

接口中的所有定义其实都是抽象的 public

接口都需要有实现类

利用接口可以多继承

public interface TimeService{
  void timer();
}

public interface UserService{
  void add(String name);
  void delete(String name);
}

public class UserServiceImp1 implements UserService,TimeService{
  //在idea中，command+n. 选择 override，重写方法
  public void add(String name){
    
  }
  public void delete(String name){
    
  }
  public void timer(){
    
  }
}

作用：

1约束

2定义一些方法，让不同的人实现

3public abstract

4public static final

5接口不能被实例化，接口无构造方法

6implements可以实现多个接口

异常

在Exception分支中有一个重要的子类RuntimeException(运行时异常)

• ArrayIndexOutOfBoundsException(数组下标越界)
• NullPointerException(空指针异常)
• ArithmeticException(算数异常)
• MissingResourceException(丢失资源)
• ClassNotFoundException(找不到类)等异常，这些异常属于不检查异常

异常处理五个关键词：

try catch finally throw throws

int a=1;
int b=0;
try{//try监控区域
  System.out.println(a/b);
}catch(ArithmeticException e){//catch捕获异常
  	System.out.println("程序出现异常，b不能为0");
}catch（Exception e）{
  
}catch(Throwable t){
  
}finally{//处理善后工作
  System.out.println("finally");
}
//可以不用fially，假设IO，资源，用来关闭

也可以主动抛出异常

if(b==0){

​ throw new ArithmeticException();

}

这篇关于JavaSE(写一些关于自己学习中觉得可能会记不清的东西。大概只适合自用）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！