一、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、JVMJREJDK
四、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();
}
}
十、面向对象的总结