Java随笔_2

时间：2015-08-12 16:30:53 阅读：144 评论：0 收藏：0 [点我收藏+]

标签：

switch类型可以对int型，char类型和String类型进行判别。

简洁写法,不用if进行判断。

 int score =61;
 boolean is = score > 60;

Java逻辑运算中有长路类型的运算，如&。

该运算计算的方式是关系式1&关系式2。

例子：

4<3&5*3<12

先计算4<3为false

再计算5*3<12为false

false与false为false

短路类型的运算不同，如&&

4<3&5*3<12

先计算4<3为false

第一个false后不再计算进行计算，整个表达式变为false。

Package在磁盘中存取时为文件名。

导入和导出文件时可以是zip文件。

静态变量是由JVM自动进行初始化。

当Main函数与想要使用的方法在同一个类中时，使用的方法必须要加上static。

类名称通常都是大写的，方法名称如何有两个单词那么第二个单词一般大写，而第一个单词是小写。

实例化类的时候通过栈内存指向堆内存，例如：

 Person per =new Person();

per变量存储为栈内存空间，其指向为堆内存空间。

面向对象三大特征：

封装

继承

多态（重载，对象多态）

Java属性和方法的封装是通过关键字private来实现。

实现该属性用get和set方法。利用get和set方法有好处，可以在get或者set方法中加入一些输入限制。

如果使用对象只使用一次，那么就可以用匿名对象，匿名对象只使用一次。比如Person这个类，Person类中有公有方法tell，匿名使用方式如下所示：

 new Person().tell();

当用户自己定义构造方法后，系统不再自己生成一个没有参数的构造方法。

String类型不是引用传递，传递到函数中不可以进行更改。类的对象属于引用传递，传递到函数中时可以进行更改。

this在构造方法中调用另一个构造方法的时候必须要放在首行，否则编译出现错误。

class Person
{
 int age;
 public Person(int age)
 {
 this();
 this.age=age;
 
 }
 public Person()
 {
 System.out.println("Empty");
 }
}

static可以节省内存。比如在一个类中，设置一个静态变量。所有的对象都有一个公有的静态变量。

使用static方法的时候，只能访问static的属性和方法，而非static的属性和方法不能进行访问。

Java只允许单继承。

在子类对象实例化之前，必须先调用父类构造函数，然后再是子类构造函数。

子类重写父类的方法时，需要方法名和参数完全相同。子类使用父类重写的方法时可以运用super关键字。

被子类重写的方法不能有比父类更加严格的访问权限。

访问权限：private<default<public。

private只有在本类中进行访问，default只能在本包下进行访问，而public在整个工程下可以进行访问。

重写与重载的区别：

使用final声明的类不能被继承。

使用final声明的方法不能被重写。

使用final声明的变量不能被修改。

抽象类被子类继承，子类必须重写抽象类中的所有抽象（！！！）方法。

接口是一种特殊的类，里面全部由全局(static)常量(final)和公共的抽象方法组成。

一个类可以同时继承抽象类和实现接口。

一个接口不能继承一个抽象类，但是可以通过extends同时继承多个接口。

实例化String对象的时候有两种方式：

String str = new String ("Hello");

采用这种方式时会在内存空间开辟两个空间存储hello。

2：直接赋值。

String str = "Hello";

只在内存中开辟一个空间进行存储，更加节省空间。

String类型进行比较的时候不要用“==”进行比较，要用equals进行比较。

双等比较的是地址，equals比较的是内容。

 String str = "Hello";
 String str1 = new String ("Hello");
 String str2 = "Hello";
 System.out.println(str==str1);
 System.out.println(str.equals(str1));
 System.out.println(str==str2);

运行结果：

string内容字符串是不可更改的，最后改变的是堆内存地址的指向，String类型作为参数传递进去后无法进行更改。

string类型中有toCharArray方法，可以将string类型转换为字符数组。

 String name = "Good";
 char data[]=name.toCharArray();

charAt：从字符串中取出指定的字符。

 String name = "Good";
 System.out.println(name.charAt(0));

byte：字符串和byte数组进行转换。

 String name = "Good";
byte[] bytes=name.getBytes();

indexof：返回第几个字符，看是否存在某个值，如果不存在字符，则返回-1。

 String name = "Good";
System.out.println(name.indexOf(‘o‘));
 System.out.println(name.indexOf(‘a‘));
 System.out.println(name.indexOf("oo"));

trim：去掉字符串的前后空格。

subString：从字符串中取出子字符串，记住返回的是string类型。

toLowerCase，toUpperCase：转换成小写，大写。

endswith,startwith：返回布尔类型，判断字符串的开头结尾字符。

replace：返回一个字符串，替换String类型中的一个字符。

StringBuffer是一个缓冲区，与String类型不同的是StrnigBuffer可以进行修改。

append：追加

insert：插入

indexof：返回第几个字符，看是否存在某个值，如果不存在字符，则返回-1。（与String类型一样）

String和StringBuffer的区别：

 String str ="Helloooo";
 for(int i = 0;i<100;i++)
 {
 str+=i;
 }
 System.out.println(str);
 StringBuffer sb = new StringBuffer();
 sb.append(str);
 for(int i = 0;i<100;i++)
 {
 sb.append(i);
 }
 System.out.println(sb);

在上述代码中，使用String类需要开辟100次空间，而使用StringBuffer则不用开辟那么多次空间，因此效率比String好。

StringBuilder被设计为StringBuffer的一个简易替换，在单线程的操作中，优先考虑该类，速度比StringBuffer快。

涉及到线程安全的问题，建议使用StringBuffer。

append：追加

insert：插入

多态性：

方法的重载与重写

对象的多态

向上转型：程序自动完成

父类对象=子类实例。

！！父类被重写的方法将会被改变。

 B bb = new B();
 A a =bb;
 a.tell1();
 a.tell2();

向下转型：强制完成

子类对象=父类实例。

欲向下转型必先向上转型。

 A a =new B();
 B b =(B)a ;
 b.tell1();
 b.tell2();
 b.tell3();

使用多态性可以节省代码。

package Test1;
class A
{
 public void tell1()
 {
 System.out.println("A----tell1");
 }
}
class B extends A
{
 public void tell2()
 {
 System.out.println("B----tell2");
 }
}
class C extends A{
 public void tell3()
 {
 System.out.println("C----tell3");
 }
}
public class Test2 {
 public static void main(String[] args){
 say(new B());
 say(new C());
 }
 public static void say(A a)
 {
 a.tell1();
 }
}

以上代码默认使用了自动向上转换，如果不利用多态性，代码会比较复杂，如下：

 public class Test2 {
 public static void main(String[] args){
 say(new B());
 say(new C());
 }
 public static void say(B b)
 {
 b.tell1();
 }
 public static void say(C c)
 {
 c.tell1();
 }
}

如果say的参数类型有100个，那么将写100个这种类型的方法，这样写麻烦很多。

instanceof 判断是否属于同一个类。

 A a =new A();
 System.out.println(a instanceof A);
 System.out.println(a instanceof B);
 A a1 = new B();
 System.out.println(a1 instanceof A);
 System.out.println(a1 instanceof B);

最好不要去继承一个已经完成好的类，没完成好的类里面最好是有抽象方法。

接口的使用，接口里面默认的方法是抽象方法。

package Test1;
interface USB
{
 void start();
 void stop();
}
class C {
 public static void Work(USB usb)
 {
 usb.start();
 System.out.println("Working");
 usb.stop();
 }
}
class USBDisk implements USB{
 public void start() {
 System.out.println("USB Start");
 }
 
 public void stop() {
 System.out.println("USB Stop");
 
 }
 
}
class Printer implements USB{
 public void start() {
 System.out.println("Printer Start");
 }
 public void stop() {
 System.out.println("Printer Stop");
 }
 
}
public class Test2 {
 public static void main(String[] args){
 C.Work(new USBDisk());
 C.Work(new Printer());
 }
}

 System.err.println("Hello World");

finally：里面的代码无论发生什么都会执行。

throws：将异常抛出，将异常抛给方法的调用者来进行处理。

throw：抛出一个实例化异常。

public class Test2 {
 public static void main(String[] args) throws Exception {
 try {
 throw new Exception("Hello");
 } catch (Exception e) {
 System.out.println(e);
 }
 }
 public static void tell(int a , int b)throws ArithmeticException{
 System.out.println(a/b);
 }
}

自定义异常：

class Exc extends Exception{
 public Exc(String msg){
 super(msg);
 }
}
public class Test2 {
 public static void main(String[] args) throws Exception {
 try {
 throw new Exc("Good");
 } catch (Exc e) {
 System.out.println(e);
 }
 }
}

Java随笔_2

标签：

原文地址：http://www.cnblogs.com/GoFly/p/4724646.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行