JavaSE

一、java虚拟接简称JVM

1、每个操作系统都可以安装一个编译java程序的虚拟机,简称JVM。JDK里面就含有JVM。

有了JVM,同一个java程序在三个不同的操作系统上都可以执行,这样就实现了java程序的跨平台性;

 

二、垃圾回收机制garbage collection,GC

1、垃圾回收是指回收不用的内存空间;

2、C语言 C++的垃圾回收是由程序员手动编写代码来回收的,这样的优点是能够在内存不使用时快速回收,准确且高效,缺点就是容易失误,容易忘记回收,导致内存使用越来越到,出现内村溢出,导致bug;

3、而java的内存回收是自动的,开了一个习题集线程自动去检测哪些内存不用了然后回收掉。不需要程序员手动编写代码来回收。优点是自动的,不需要程序员来编写,不会忘记内存回收,缺点是内存回收不及时;

 

三、JDK和JRE

1、JDK(java development kit java)开发工具包,包括了JRE、编译工具(java.exe)、打包工具(jar.exe)等,是java程序员必须要下载和安装的文件;

2、JRE(java runtime environment)java运行环境,如果不开放java,只需要运行java文件,那么下载JRE就可以了;

3、JVM{\color{Red} \subset }JRE{\color{Red} \subset }JDK 

 

四、JavaBean

1、JavaBean是一种java语言写成的可重用组件

2、符合以下特性:

  • 属性私有化,并每个属性都有get和set方法
  • 有一个无参构造函数

3、JavaBean就是一个实体类有私有属性,并且为属性编写一个get和set方法,以及加上一个无参的构造函数,比如以下的学生类student;

public class Student{
    private int id;
    private String name;

    public Student(){

    }    

    public int getId(){
        return this.id;
    }
    
    public void setId(int id){
        this.id = id;
    }

    public String getName(){
        return this.name
    }

    public void setName(String name){
        this.name = name;
    }

    
}
    

 

 五、面向对象的特征三:多态性

1、重载和重写

  • 重写是本类有多个同名的方法,方法的形参个数不同或者类型不同;
  • 重写是子类重写父类的方法,方法名与父类相同;

2、多态是面向对象中最重要的概念之一,在java中有两种体现:

  • 方法的重载和重载
  • 对象的多态---可以直接应用在抽象类和接口上

3、java引用变量有两个类型:编译时类型和运行时类型

若编译时类型和运行时类型不同,就会出现对象的多态;

子类可以看成是特殊的父类,所以父类类型的引用可以指向子类的对象:向上转型,能使用的方法减少;

//Student继承Person类
//正常情况下的创造对象
Person p = new Person();
Student t = new Student();


//父类的引用对象可以指向子类的实例
Person p1 = new Student();



//对p2实例化两次,结果p2指向Student的引用对象;
Person p2 = new Person();
p2 = new Student();



4、多态是什么?

多态就是同一个行为具有多个不同表现形式或形态的能力。

多态就是同一个接口,使用不同的实例而执行不同操作。

如下所示,不同的对象cat和dog调用同一个方法action,会表现出不同的行为;

//伪代码
class Animal(){
    public void action(){

    }

}

class Cat extends Animal(){
    public void action(){
        System.out.println("Cat's action");
    }
}

class Dog extends Animal(){
    public void action(){
        System.out.println("Dog's action");
    }
}

public class Test(){
    public static void main(String[] args){
        Animal cat = new Cat();
        
        Animal dog = new Cat();

        cat.action();
        dog.action();

    }

}

5、多态的条件

  • 继承
  • 重写
  • 父类引用指向子类对象  Animal cat = new Cat();

 

六、操作符

1、instanceof操作符:检验是本类或者是属于之类;

//a instanceof b :检验a是否为b类的对象 ,返回值为Boolean型

public class Person extends Object{}
public class Student extends Person{}

Studnet s = new Student();

Boolean b  = s instanceof Person; // b== true;

 

 

七、关键字

1、static---静态的

//静态方法
//静态方是独立于对象之外的对象,静态方法不能使用非静态变量
public static void main(String[] args){}



//静态变量,也加类变量
//可以通过类名来访问静态变量
static String country = "China";

2、main方法

/*
理解main方法的语法
使用cmd的方式来运行java
$:javac testMain.java 
$:java testMain abc 123 sss
$: abc
$: 123
$: sss
*/
public class testMain{

	public static void main(String[] args){
		for(int i=0; i<args.length; i++0){
			System.out.println(agrs[i])
		}
	}
	
} 

3、final--"最终的"

final class  
final void getId(){}
final MAX_SUM = 100;

final修饰类

public final class TestPerson{
	int age;
	String name;
}

class Student extends TestPerson{}
//编译出错,final修饰的类不能被继承;

final修饰方法 

public  class TestPerson{
	int age;
	String name;

	public final  void test(){

	}
}

class Student extends TestPerson{
	public void test(){} //编译出错,final修饰的方法不能重写;
}

final修饰变量是常量: 

public  class TestPerson{
	int age;
	String name;

	final String name = "123" ; //final修饰的变量是常量,且必须显示赋值;

	final static NAME = "456"; 
	//final和static一起修饰表示全局常量;


	public   void test(){

	}
}

八、设计模式

设计模式是总结出来解决问题的“套路”;

1、单例设计模式----只有一个实例

  • 什么情况下,类只被实例化一次?(什么时候使用单例模式?)
    例如这个对象的创建需要消耗大量的时间和资源;
    比如Servlet对象就是单例模式,一个Servlet类只有一个对象;
  • 单例模式的实现方法
    饿汉式:
    /*
    实现饿汉式的单例模式:
    */
    
    public class Single{
    	//私有的构造方法,在别的类中创造对象时就不能用new了;
    	private Single(){
    
    	}
    
    	//室友类型的类变量
    	private static Single  single = new Single();
    
    	//共有的方法,来访问single对象
    	public static String getInstance(){
    		return single;
    	}
    
    
    }

     访问Single对象

    public class TestSingle(){
    	public static void main(String[] args){
            
            //无论调多少次这个方法,反回的都是同一个single对象
    		Single single = Single.getInstance();
    		
    	}
    }

     

  • 懒汉式:最开始对象是null,直到有第一个人调用时,才new一个对象,之后所有调用我的都有这个对象;

    public class Single1{
    
    	private Single1(){
    
    	}
    
    	private static Single1 s1 = null;
    
    	public static Single1 getInstance(){
    		if(s1 == null){
    			s1 = new Single1();
    		}
    
    		return s1;
    	}
    
    } 

     

    public class testSingle1{
    
    	public static void main(String[] args){
    		Single1 s= Single1.getInstance();   
            Single1 s1= Single1.getInstance();  
            
    	}
    	
    } 

     

2、模板方法设计模式 templateMethod

抽象类体现的就是模板方法设计模式;

抽象类作为多个子类的通用模板;

public abstract class Template{

	public abstract void code();

	public final void getTime(){
		long start = System.currentTimeMillis();
		code();
		long end = System.currentTimeMillis();
		System.out.println("code()方法的时间:"+(end - long ))
	}
}

class  TestTemp extends Template{

	public void code(){
		int k =0 ;
		for(int i=0; i< 5000; i++){
			k += 1;
		}
		Sysem.out.println(k);
	}
}


-----------------------------------------------------------
public class Test{
	public static void main(){
		TestTemp t = new TestTemp();
		t.getTime();
	}
}

3、 工厂方法(FactoryMethod)

public interface  BWM{

	void showIofo();

}


 class BWM3 implements BWM {
 	public void showIofo(){
 		System.out.println("BWM3")
 	}
}


 class BWM5 implements BWM {
 	public void showIofo(){
 		System.out.println("BWM5")
 	}
}


 class BWM7 implements BWM {
 	public void showIofo(){
 		System.out.println("BWM7")
 	}
}
public interface BWMFactory{

	BWM productBWM();
}


class BWM3Factory implments BWMFactory{
	public BWM productBWM(){
		System.out.println("product BWM3");
		return new BWM3();
	}
}

class BWM5Factory implments BWMFactory{
	public BWM productBWM(){
		System.out.println("product BWM5");
		return new BWM5();
	}
}

class BWM7Factory implments BWMFactory{
	public BWM productBWM(){
		System.out.println("product BWM7");
		return new BWM7();
	}
}
public class test{
	public static void main(String[] args){
		BWM b3 = new BWM3Factory().productBWM();
		BWM b5 = new BWM5Factory().productBWM();
		BWM b7 = new BWM7Factory().productBWM();

		b3.showIofo();
		b5.showIofo();
		b7.showIofo();

	}
}

 

 九、内部类

1、例子

public class Test3{

	int i;
	public int j;
	private int k;

	class A{
		
		public void setTestsFileds(){
			Test3.this.i = 1;
			Test3.this.j = 2;
			Test3.this.k = 3;
		}

	}

	public void setInfo(){
		new A().setTestsFileds();
	}

	public void showInfo(){
		System.out.println(this.i);
		System.out.println(this.j);
		System.out.println(this.k);
	}

	public static void main(String [] args){
		Test3 t = new Test3();
		t.setInfo();
		t.showInfo();

	}

}

 

 

十、面向对象的总结

 

 

 

 

 

 

 

 

 

 

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值