JavaSE(写一些关于自己学习中觉得可能会记不清的东西。大概只适合自用）

本文主要是介绍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

这个为重写

重写只和非静态有关

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

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

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

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

False

true

false

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

Java教程

JavaSE(写一些关于自己学习中觉得可能会记不清的东西。大概只适合自用）

JAVA01

JAVADoc

Scanner

JAVA方法

重载

可变参数

递归

数组

JAVA面向对象

构造器

面向对象（封装）

继承

super

方法重写

多态

instanceof

static

抽象类

接口

异常

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯