java拾笔-1
数据类型：之类型转换：
char a='a';//a这个字符在ASCII编码上位于97位 char b='中'; int i=a;//自动类型转换 char d=48; System.out.println(i);//97 System.out.println(d);//0 这个0不是整形0 而是一个字符0 int i2=b; System.out.print(i2);//'中'这个字符在ASCII编码上位于48位
在取值范围内，int转换为byte，short，char不需要强制转换，强制类型转换有时会损失精度
byte，short，char之间相互转换需要转换为int进行过度
i++,++i
int i=5; int k=i++; System.out.println(k);//5 System.out.println(i);//6 int m=++i; System.out.println(m);//7 System.out.println(i);//7
位运算&，|，^ 建立在二进制数的运算
System.out.print(1&2);//0 System.out.print(1|2);//3 System.out.print(1^2);//3
java面向对象：
面向对象方法将世界看作一个个相互独立的对象，只有在某种外部力量的驱动下，对象之间才会依据某种规律相互传递信息。不像面向过程那样把世界看作是一个紧密关联的系统。一个车的后视镜坏了，面向过程是换整辆车，面向对象是换后视镜。
Java中类和对象：
对象保存在堆中
对象的引用（用来保存对象在堆中的地址），保存在栈中
private:
public void setType(String _type){ type=_type; } public String getType(){ return type; }
computer.setType("inter i5");
System.out.print(computer.getType());
构造方法：
一种特殊的方法，是一个与类同名且没有返回值类型的方法。其功能主要完成对象的初始化，当类实例化一个对象时会自动调用构造方法，可以重载
注意：1.构造方法是特殊的成员方法，与类同名，在对象实例化时由虚拟机自动调用
2.没有返回类型，也不能有返回值
3.每个对象在生成时都必须执行构造方法，并且只能执行一次
4.如果构造方法调用失败，那么对象也无法创建
5.在没有定义构造方法的情况下，类会自动产生一个无参数的默认构造方法，这个默认构造方法什么都不做
6.一旦显式的定义了构造方法，默认构造方法自动消失
static：
- 只有在所有对象都是同一个属性值的时候我们才建议到属性上用static修饰
- 在static的方法或者语句块中不能使用this、super关键字
- 在static中不能使用非static的成员(属性、方法)
- 在非static中可以使用static的成员(属性和方法)也可以使用非static的成员
public class Student { String name; //成员变量 static int age;//18 //静态变量 public void eat(){ //成员方法 System.out.println(name);//能 System.out.println(age);//能 play();//能 } public static void play(){ //静态方法 //System.out.println(name);//不能 System.out.println(age);//能 //eat();//不能 } }
* 1.不管创建多少个对象，静态代码块始终只执行一次，因为我们的类只加载一次
* 2.静态代码块始终在成员代码块之前执行，因为他在类加载时就执行
* 3.静态代码一般用来做一些全局的初始化操作
//Super：
public Dog(){ //super();如果不写，默认执行父类的无参构造 System.out.println("Dog类的无参构造"); } public Dog(String name){ this();//调用本类的无参构造 this.name=name; }
- 子类的构造方法中必须调用其父类的构造方法
- 如果未显示，则默认调用父类无参构造 如果显示，则super必须位于第一行
- 如果未显示而父类没有无参构造则程序报错（一般要写上无参构造，以防以后报错）
final：
1.final修饰类，则该类不允许被继承
2.final修饰方法，则该方法不允许被重写
3.final修饰属，变量，一旦赋值将不可改变
final关键字经常和static一起使用来定义一个常量，这时候我们一般将变量名大写
final static int MONTH_NUM=12;
Object类常用方法的使用：
toString方法：toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂
的信息表达式。建议所有子类都重写此方法
Dog dog=new Dog(); System.out.print(dog)//默认输出dog.toString()，输出dog的地址 @Override public String toString(){ return "想要输入的格式";// }
equals方法：Object类的equals方法默认比较的是对象的引用是否指向同一个内存地址，如果需要判断自
定义类型对象内容是否相等，则需要重写equals方法(字符串重写了equals方法)
==：比较的是值是否相同如果相同返回true,否则返回false如果是引用数据类型变量比较的是地址值(地址
值相等返回true，否则返回false)
Person p1=new Person("宏彬"，25)； Person p2=new Person("宏彬"，25)； System.out.print(p1==p2);//false System.out.print(p1.equals(p2));//false new开辟地址，p1,p2地址不相同 @Override public boolean equals(Object obj){ if(this==obj){ retrun true; } if(obj instanceof Person){ Person p=(Person) obj; if(this.name.equals(p.name&&this.age==p.age){//根据需求写equals return true; } } return false; }
单例模式：
1.饿汉式：（缺点：占内存）
//Human.java public class Human { static Human human=new Human();//对外提供一个可以可以得到当前类得对象的公共方法（返回值应该是当前类的类型） private Human(){ } public static Human getHuman(){ return human; } } //Test.java public class Test { public static void main(String[] args){ Human h1=Human.getHuman(); Human h2=Human.getHuman(); System.out.println(h1); System.out.println(h2); System.out.print(h1.equals(h2)); } } // se.Human@15db9742 se.Human@15db9742 true
2.懒汉式
//缺点：线程的同步 public class Human { static Human human; private Human(){ } public static Human getHuman(){ if(human==null){ human=new Human(); } return human; } }
抽象类：
//A.java //抽象类可以拥有抽象方法，也可以拥有不抽象的方法 //抽象类可以没有抽象方法，但抽象方法必须出现在抽象类中，抽象方法和抽象类不能被final修饰 public abstract class A {//抽象类 public abstract void m1();//抽象方法 public void m2(){ System.out.print("m2的方法"); } }
//B.java public class B extends A{ public static void main(String[] args){ //A a=new A();Error A是抽象的，无法被实例化 B b=new B(); b.m1(); } @Override//一个非抽象类继承了抽象类，则必须将抽象类中的抽象方法重写 public void m1() {//抽象类有构造方法，他的构造方法是给子类创建对象用的 System.out.print("B的m1方法"); } }
interface：
/** * java中的接口 * 1.接口也是一种引用类型 * 2.定义：[修饰符] interface 接口名{} * 3.在接口中只能出现：常量，抽象方法 int a=1;等价于final static int a=1; public void m1;默认加上了abstract * 4.接口没有构造方法，无法被实例化 * 5.接口可以有子类，但不叫继承，而是叫实现，用关键字implements表示 * 6.单继承，多实现 一个类可以同时实现多个接口 * 7.但一个非抽象的类实现了某个接口，则必须重写该接口中所有的抽象方法 * 8.一个类多实现的语法： implements 接口1,接口2 */ public class InterfaceTest implements Interface01,C { public static void main(String [] args){ } public void m10() { } @Override public void m2() { } }
多态：
//DuotaiTest1.java：
Animal animal=new Animal(); Animal dog=new Dog();//向下转型 Dog a=(Dog) animal;//保证这个动物是Dog类。向上转型 Dog a=(Dog)new Animal()
//DuotaiTest2.java Animal animal=new Bird(); if(animal instanceof Dog){//2、判断animal是否是Dog类，用到instanceof关键字。向上转型 Dog dog=(Dog) animal; System.out.print(dog);//1、Bird cannot be cast to faceObj4.Dog，animal是Bird类 } else{ System.out.print("不是狗"); }
//Master.java
// public void feed(Dog dog){
//// System.out.println("喂狗的方法");
// }
// public void feed(Bird bird){
// System.out.print("喂鸟的方法");
// }
public void feed(Animal a){ System.out.println("喂"+a+"的方法");
//DuotaiTest3.java Master master=new Master(); Dog dog=new Dog(); Bird bird=new Bird(); master.feed(dog); //Animal a=dog 多态//喂faceObj4.Dog@15db9742的方法
master.feed(bird); //Animal a=bird//喂faceObj4.Bird@6d06d69c的方法
//Animal.java public void move(){ System.out.print("我是动物我能动"); } //当子类全都重写了move类，父类中move类不能不写，由于Master.java中用了a.move，会报错move多态，找不到父类中move方法 //用抽象解决 //public abstract void move();
