静态
用法:是一个修饰符,用于修饰成员(成员变量,成员函数)
所有对象都可以访问,被对象共享
当成员被静态修饰后,就多了一个调用方式,除了可以被对象调用外,还可以直接被类名调用。
类名.静态成员
静态特点:1.随着类的加载而加载(消失而消失)
2.被所有对象所共享
3.优先于对象存在
4.可以直接被类名所调用
类变量对应于类。实例变量对应于对象。
静态的使用注意事项:
1.静态方法只能访问静态成员。
非静态方法既可以访问静态方法也可以访问非静态方法
2.静态方法中不可以定义this,super关键字。
因为静态优先于对象存在,所以静态方法中不可以出现this。
public class Person {
private String name;
private int age;
public final static int EYE_NUM = 2;
public static void eat(){
System.out.println("吃饭");
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class NewPerson {
public static void main(String[] args) {
Person zhangsan = new Person();
System.out.println(Person.EYE_NUM);
}
}
运行结果:2
import 静态,引用常量
import static 静态.Person.EYE_NUM;
import 静态.Person;
public class Inport {
public static void main(String[] args) {
Person zhangsan = new Person();
System.out.println(EYE_NUM);
}
}
运行结果:2
final关键字
final表示最终的意思,用final修饰的类,不能被继承。
final修饰的方法不能被重写,修饰的变量不能修改值。
用static final修饰的变量其实就是常量。
常量的命名的规则:
全部都用大写字母,单词用下划线分隔开。
上面的程序中用了static final来修饰一个变量,使其变成了常量。
math和一些包装类的方法
Math.floor();舍去小数点后所有
Math.ceil();舍去小数点后所有,然后小数点前面+1
Math.rint();四舍五入
Math.sqrt();开平方根
三角函数:
public static double sin(double a);
把sin换成其他的三角函数就可以用相应的三角函数公式。
抽象方法和匿名类
抽象方法:抽象方法没有方法体,必须在抽象类中
其子类也必须是抽象类,除非子类中将抽象方法实现。
匿名内部类:一般在只是用一个此类对象时使用,相当于一个类继承了赋予的类,然后用此类构建了一个对象。
public abstract class Student {
public abstract void readBook();
}
public class SchoolBoy extends Student{
public void readBook() {
System.out.println("语文数学英语");
}
}
public class Test {
public static void main(String[] args) {
Student lisi = new SchoolBoy();
//抽象类建立对象可以通过非抽象的子类来完成
lisi.readBook();
Student zhangsan = new Student(){
public void readBook(){
System.out.println("读书");
}//使用匿名内部类定义方法
};
zhangsan.readBook();
}
}
运行结果:
接口
interface,接口也是抽象的,能有常量,不能有变量,只能有抽象的方法和相应参数。接口不用考虑实现的问题。定义接口就是定义编程中的一些准则。
创建了接口后,有类要用到接口就在类名后加上implements 接口名
public interface Car {
public void run();
}
public interface Load {
public void getGoods(String s);
}
public class Truck implements Car{
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("跑");
}
}
public class BigTruck extends Truck implements Load{
@Override
public void getGoods(String s) {
// TODO Auto-generated method stub
System.out.println(s);
}
}
public class Test {
public static void main(String[] args) {
BigTruck t = new BigTruck();
t.run();
t.getGoods("100");
}
}
运行结果:
面向接口的编程+多态
多态的定义:指允许不同类的对象对同一消息作出响应,即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发消息指函数的调用)
简单来说就是同一时间发生在不同的对象上会有不同的结果。
多态的三个条件:1.要有继承 2.要有重写 3.父类引用指向子类对象
程序简介
定义了一个打印的程序,有三种接口,Paper:代表打印用的纸张
Ink:打印墨水的颜色 Print:打印机打印。每种接口都有两个类来实现,并且重写了接口的方法。最后一个Person类来归纳这些类,并且提供方法来完成打印过程。
public interface Ink {
public String getInk();
}
public interface Paper {
public String getPaper();
}
public interface Print {
public void getPrint(Paper paper,Ink ink);
}
public class BeijingInk implements Ink{
@Override
public String getInk() {
return "北京红色";
}
}
public class ShanghaiInk implements Ink{
@Override
public String getInk() {
return "上海黑色";
}
}
public class ChenguangPaper implements Paper{
@Override
public String getPaper() {
return "A4";
}
}
public class OtherPaper implements Paper{
@Override
public String getPaper() {
return "B2";
}
}
public class HpPrint implements Print{
@Override
public void getPrint(Paper paper, Ink ink) {
System.out.println("用纸是"+paper.getPaper()+",用的墨水是"+ink.getInk());
}
}
public class ApplePrint implements Print{
public void getPrint(Paper paper, Ink ink) {
System.out.println("苹果打印机打印用纸是"+paper.getPaper()+",用的墨水是"+ink.getInk());
}
}
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;
public class Person {
public Paper usePaper(){
Paper paper = new ChenguangPaper();
return paper;
}
public Ink useInk(){
Ink ink = new ShanghaiInk();
return ink;
}
public Print usePrint(){
Properties properties = new Properties();
String s = "";
try {
properties.load(new FileInputStream("config.properties"));
s = properties.getProperty("Print");
System.out.println(s);
}
catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Print print = null;
if(s.equals("hp")){
print = new HpPrint();
}else if(s.equals("apple")){
print = new ApplePrint();
}
// Print print = new ApplePrint();
return print;
}
public void print(){
Paper paper = usePaper();
Ink ink = useInk();
Print print = usePrint();
print.getPrint(paper, ink);
}
class Servent{
String skill;
}
}
import FaceToInterface.Person.Servent;
public class Test {
public static void main(String[] args) {
Person lisi = new Person();
lisi.print();
//Servent archer = new Person().new Servent();
}
}
运行结果:
单例设计模式
单例设计模式:解决一个类在内存中只存在一个对象。
想要保证对象唯一。
1.为了避免其他程序过多建立该类对象。先控制禁止其他程序建立该类对象。
2.还为了让其他程序可以访问到该类对象,只好在本类中自定义一个对象。
3.为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式。
怎么实现:
1.将构造函数私有化。
2.在类中创建一个本类对象。
3.提供一个方法可以获取到该对象。
public class Student {
private static Student s;
private Student(){
}
public static Student getstudent(){
if(s==null){
s = new Student();
}
return s;
}
}
public class getStudent {
public static void main(String[] args) {
Student wangwu = Student.getstudent();
Student lisi = Student.getstudent();
System.out.println(wangwu);
System.out.println(lisi);
}
}
运行结果:
递归
反复调用就是递归
class Add{
private int i = 1;
public int sum = 0;
public void add(){
if(i<1001){
sum+=i;
i++;
add();
}
}
}
public class Sum {
public static void main(String[] args) {
Add a = new Add();
a.add();
System.out.println(a.sum);
}
}
运行结果:500500