JavaBase,我写的这些你知道吗?
几个变量的区别懂?
局部变量(顾名思义只能在一个方法里面使用的变量)
实例变量 (必须通过实例一个对象(new一个对象),用对象.变量属性)
类变量(用static修饰的变量,可以直接获取)
常量 (不可更改的变量)
代码一看便知
public class Test {
String name;
static int age;
// 常量修饰的变量一般全大写--->一种规范 因为是不可变的 必咻初始化值
final static double SALARY=100.00;
public static void main(String[] args) {
//局部变量 -->必须初始化值
boolean flag=true;
System.out.println(flag);
//实例变量-->初始化默认值
Test test = new Test();
System.out.println(test.name);
//类变量-->初始化默认值
System.out.println(age);
System.out.println(SALARY);
}
}
关于运算 Math会用?
幂运算利用Math工具类
//表示2的3次方 返回的数据类型是double
double pow = Math.pow(2, 3);
System.out.println(pow);
字符串连接问题
public static void main(String[] args) {
//字符串拼接问题
int a=13;
int b=14;
System.out.println(a+b+"");//27--->在字符之前是运算
System.out.println(""+a+b);//1314--->在字符之后是拼接
}
可变参数是啥?
一个方法只能有一个可变参数,且必须在方法的最后一个参数,任何普通的参数必须在它之前声明
public static void main(String[] args) {
Test test = new Test();
test.test("小黑猪",1,2,3,4,5);
System.out.println("--------------------");
//可变参数本质就是数组
test.test("小黑猪",new int[]{1,22,133});
System.out.println("--------------------");
test.test("小黑猪");
}
public void test(String str,int... x){
System.out.println(str);
if (x.length==0){
System.out.println("no parameter");
}
for (int i = 0; i < x.length; i++) {
System.out.println(x[i]);
}
}
supper、this注意啥啊
supper:
-
调用父类的构造方法必须在构造方法的第一行
-
必须出现在子类的方法中或者构造方法中
-
supper和this不能同时调用构造方法
-
构造方法:
this();本类的方法
supper();父类的方法
public class Person {
protected String name;
// public Person() {
// System.out.println("我是所有的父类......");
// }
public Person(String name) {
System.out.println(name+"说我是所有的父类......");
}
}
public class Singer extends Person {
private String name;
// public Singer() {
// //默认调用父类的无参构造方法
// //自行调用时必须放在方法的第一行
super();
// System.out.println("I am a singer!");
// }
/*
当父类只有只有有参构造方法时,必须在子类中实现super(参数)的调用 否则报错
*/
public Singer(String name) {
super(name);
System.out.println(name + " is a singer!");
this.name = name;
}
}
public class Test {
public static void main(String[] args) {
// Singer singer = new Singer();
Singer singer = new Singer("小猪佩奇");
}
}
instanceof怎么用捏?
instanceof用于应用类之间的比较,如果两个没有关系的类进行比较,编译不通过
有Person和Singer两个自定义的类 随意啦!!
public static void main(String[] args) {
/*
obj->person->singer
obj->person->dancer
obj->string
obj是万类之源
instanceof用于应用类之间的比较,如果两个没有关系的类进行比较,编译不通过
*/
Object obj=new Singer();
System.out.println(obj instanceof Object);//true
System.out.println(obj instanceof Person);//true
System.out.println(obj instanceof Singer);//true
System.out.println(obj instanceof Dancer);//false
System.out.println(obj instanceof String);//false
System.out.println("------------------------");
Person person=new Singer();
System.out.println(person instanceof Object);//true
System.out.println(person instanceof Person);//true
System.out.println(person instanceof Singer);//true
System.out.println(person instanceof Dancer);//false
// System.out.println(person instanceof String);//编译不通过
System.out.println("------------------------");
Singer singer=new Singer();
System.out.println(singer instanceof Object);//true
System.out.println(singer instanceof Person);//true
System.out.println(singer instanceof Singer);//true
// System.out.println(singer instanceof Dancer);//编译不通过
// System.out.println(person instanceof String);//编译不通过
}
初始化顺序输出?
public class Person {
//第二 ---->匿名代码块 可用于赋初始值
{
System.out.println("匿名代码块");
}
//第一 ---->静态代码块 只初始化一次
static {
System.out.println("静态代码块");
}
//第三 ---->无参构造器
public Person() {
System.out.println("无参构造器");
}
public static void main(String[] args) {
new Person();
}
}
内部类你知道多少?
成员内部类
局部内部类
静态内部类
匿名内部类
代码一运 啥都懂
public class Person {
private String name;
private int age=10;
public void all(){
System.out.println("外部类-方法");
new Person5().get();
}
//局部内部类
public class Person2{
private String goods;
public void eat(String name,String goods){
String str = new Person3().str;
System.out.println(name+" 吃了一个 "+str+goods);
//内部类可以直接获取外部类的私有属性
System.out.println(name+" 今年 "+age);
System.out.println("局部内部类-方法");
//匿名内部类
Person4 person4 = new Person4() {
public void doing() {
System.out.println("匿名内部类-方法");
System.out.println(name + " 摘了一个 " + str + goods);
}
};
person4.doing();
}
}
//静态内部类
public static class Person5{
public void get(){
System.out.println("静态内部类-方法");
}
}
}
/*
一个java类文件中 只能有一个public class 但是可以有多个class
*/
//成员内部类
class Person3{
public String str="red ";
public static void main(String[] args) {
System.out.println("成员内部类-main方法");
Person person = new Person();
person.all();
Person.Person2 person2 = person.new Person2();
person2.eat("小猪","apple");
}
}
//接口 -->函数式接口-->可用lambda 1.8特性
interface Person4{
public void doing();
}
异常抛出-够简单吧
public class Person {
private String name;
private int age=10;
public int all(int x,int y){
try {
if (x==0){
throw new RuntimeException();//主动抛出异常
}
} catch (RuntimeException e) {
x=10;
e.printStackTrace();
}finally {
return y/x;
}
}
}
class TestE{
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.all(20, 10));
}
}
自定义异常你怎么玩的?
public class MyException extends Exception {
private int code;
public MyException(int code) {
this.code = code;
}
@Override
public String toString() {
return "MyException{" +
"code=" + code +
'}';
}
}
//测试
public static void main(String[] args) {
System.out.println(getX(0));
}
public static int getX(int x){
try {
if (x==0){
throw new MyException(x);
}
} catch (MyException e) {
x=10;
e.printStackTrace();
}finally {
return x;
}
}