JavaSE(写一些关于自己学习中觉得可能会记不清的东西。大概只适合自用)
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了JavaSE(写一些关于自己学习中觉得可能会记不清的东西。大概只适合自用),小编现在分享给大家,供广大互联网技能从业者学习和参考。文章包含10202字,纯文字阅读大概需要15分钟。
内容图文
![JavaSE(写一些关于自己学习中觉得可能会记不清的东西。大概只适合自用)](/upload/InfoBanner/zyjiaocheng/593/a8b5c3ffc7e9482eac5489a785cd323b.jpg)
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(写一些关于自己学习中觉得可能会记不清的东西。大概只适合自用)全部内容,希望文章能够帮你解决JavaSE(写一些关于自己学习中觉得可能会记不清的东西。大概只适合自用)所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错,欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 gblab@vip.qq.com 举报,一经查实,本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。